Merge pull request #1200 from pyvideo/djangocon-us-2024

DjangoCon US 2024

djangocon-us-2024/category.json

@@ -0,0 +1,3 @@
+{
+    "title": "DjangoCon US 2024"
+}

djangocon-us-2024/videos/a-brief-history-of-django.json

@@ -0,0 +1,26 @@
+{
+    "description": "We are better programmers than historians or archivists.  There are a few great stories from the very early days of Django and how we managed to get it Open Sourced.   They are told in the hallways and at dinner amongst us old timers, but as Django is poised to enter its second decade it seems appropriate to record some of these stories for posterity. \n\n- How did the make up of the team and The World Company itself impact early Django design choices? \n- The infamous meeting where we got approval to Open Source Django\n- Why the BSD license?\n- Did we know what we were doing?",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/a-brief-history-of-django/"
+        }
+    ],
+    "speakers": [
+        "Frank Wiles"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/yLwx4_099aQ/maxresdefault.jpg",
+    "title": "A Brief History of Django",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/yLwx4_099aQ"
+        }
+    ]
+}

djangocon-us-2024/videos/a-guided-tour-through-postgres-internals.json

@@ -0,0 +1,26 @@
+{
+    "description": "Exercising your Postgres skills on this tour will give you a leg up in working with your Django app and understanding performance related to your database. The guide will provide all the gear, necessary commands, and queries for your adventure. You don\u2019t want to miss the view of your database when we get to the top. All skill levels are welcome.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/a-guided-tour-through-postgres-internals/"
+        }
+    ],
+    "speakers": [
+        "Elizabeth Garrett Christensen"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/nOeNOKBXdUs/maxresdefault.jpg",
+    "title": "A Guided Tour Through Postgres Internals",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/nOeNOKBXdUs"
+        }
+    ]
+}

djangocon-us-2024/videos/a-related-matter-optimizing-your-webapp-by-using-django-debug-toolbar-select-related-and-prefetch-related.json

@@ -0,0 +1,26 @@
+{
+    "description": "What happens in an HTTP request-response cycle is often difficult to understand. Optimizing database queries is a crucial aspect of web development, yet it often remains shrouded in mystery for many beginners. By attending this talk, attendees will gain practical insights into how to leverage django-debug-toolbar to inspect an HTTP request-response cycle. By revealing and fixing pathological queries, developers can improve application performance and user experience. The talk will cover indexing, select_related, prefetching, and other optimization strategies.\n\nDuring the session, I will guide attendees through the following key points:\n1. Understanding Query Execution: Exploring the anatomy of a QuerySet, focusing on immutability, lazy evaluation, and the fact that a QuerySet is not a query.\n2. Introduction to django-debug-toolbar: An overview of what django-debug-toolbar is and how it can be integrated into Django projects.\n3. Identifying Pathological Queries: Techniques for using django-debug-toolbar to identify slow or inefficient database queries within an HTTP request.\n4. Strategies for Optimization: Practical tips and strategies for optimizing identified queries, including indexing, select_related, prefetching, and other optimization.\n5. Real-World Examples: Illustrative examples and case studies demonstrating the impact of query optimization on application performance.\n\nThis talk is ideal for beginners in Django development who are looking to deepen their understanding of query optimization and improve the performance of their Django applications. Attendees should have a basic familiarity with Django concepts such as models and basic database design, but no prior experience with query optimization is required.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/a-related-matter-optimizing-your-webapp-by-using-django-debug-toolbar-select-related-and-prefetch-related/"
+        }
+    ],
+    "speakers": [
+        "Christopher Adams"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/PtrBQj9lPVA/maxresdefault.jpg",
+    "title": "A Related Matter: Optimizing your webapp by using django-debug-toolbar, select_related(), and prefetch_related()",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/PtrBQj9lPVA"
+        }
+    ]
+}

djangocon-us-2024/videos/an-opinionated-guide-to-modern-django-forms.json

@@ -0,0 +1,26 @@
+{
+    "description": "Django forms have experienced a significant renaissance within the Django community, after years of being what felt like an afterthought. Recent releases to Django have brought major improvements to built-in form templating and rendering. Instead of writing APIs to support forms rendered by the JS framework of the week, you can now use Django forms to render dynamic, interactive, responsive forms using only the batteries provided by Django, various third-party Django packages, and a handful of small, focused JavaScript utility libraries. And if you're willing to do a little bit of the leg work yourself, you can even get by without those third-party Django packages.\n\nIn recent years, web development has started to see a shift away from complex JavaScript-heavy architectures toward more streamlined, HTML-centric approaches. Technologies like HTMX and Unpoly.js enable SPA-like experiences through server-rendered HTML, pairing nicely with Django\u2019s template language. Similarly, libraries like Alpine.js and Stimulus enhance static HTML with dynamic behaviors inline, eliminating the need for comprehensive frameworks. Additionally, CSS frameworks like Tailwind CSS adopt a utility-first approach, simplifying the creation of  maintainable CSS. \n\nThis shift towards an HTML-centric approach to building web applications is complemented nicely by the recent improvements to Django forms. By leveraging these new capabilities, Django forms can now be used to render forms that are more easily maintainable, more responsive, more accessible, and -- to the end user -- just as interactive as one built using one of the many JS frameworks.\n\nBy the end of this talk, attendees will have a deeper understanding of the power and potential of Django forms, equipped with the knowledge to implement them effectively in their projects.\n\n### Outline\n\n- Introduction to Django forms, including a quick historical overview of where they have come\n- Exploration of a few new Django form features: template-based form rendering and `as_field_group`\n- Styling forms, fields, and errors using modern CSS features, with a focus on Tailwind CSS\n- Dynamic behavior with minimal JavaScript, with a focus on Alpine.js\n- Inline validation using AJAX, with a focus on HTMX\n- Useful third-party Django form packages and why you may not need them anymore\n- Hands-on demonstration of a simple form using all of the above\n\nThis talk will be suitable for anyone who has a basic understanding of Django.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/an-opinionated-guide-to-modern-django-forms/"
+        }
+    ],
+    "speakers": [
+        "Josh Thomas"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/mpS9DLTSW88/maxresdefault.jpg",
+    "title": "An Opinionated Guide to Modern Django Forms",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/mpS9DLTSW88"
+        }
+    ]
+}

djangocon-us-2024/videos/api-maybe-bootstrapping-a-web-application-circa-2024.json

@@ -0,0 +1,26 @@
+{
+    "description": "The last couple of years seem to have changed everything. Particularly with HTMX, but also related technologies like Alpine.js and Tailwind CSS, we've rapidly gone from a world where seemingly the only option was \"API First\".\n\nThis is the story of bootstrapping a new application in these latter days. On a core of almost old-school Django combined with HTMX, with a just sprinkling of Alpine.js, we've been able to build a rich and interactive web application, with hardly a JSON response or payload in sight.\n\nWe'll show the integration patterns we've learnt, and what the limits of those might be.\n\nFinally, we'll look at what the future might bring. As we grow the application we're looking whether we will need edge computing, offline, and richer behaviour purely on the client. Is that the limit of the hypermedia driven approach? Is that where we need an API? It's not clear: it's still very much \"API Maybe\".",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/api-maybe-bootstrapping-a-web-application-circa-2024/"
+        }
+    ],
+    "speakers": [
+        "Carlton Gibson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/I6XP7DweLzc/maxresdefault.jpg",
+    "title": "API Maybe: Bootstrapping a Web Application circa 2024",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/I6XP7DweLzc"
+        }
+    ]
+}

djangocon-us-2024/videos/choosing-wisely-spa-vs-htmx-for-your-next-web-project.json

@@ -0,0 +1,26 @@
+{
+    "description": "As web developers, we want to select the right architecture pattern for our projects. Web applications are inherently complex, and your choice will affect how you manage that complexity.\n\nChoosing a SPA pattern offers rich user experiences with rich interactivity and navigational transitions, but it also introduces complexity in state management, development cost, maintenance, security, and performance. \n\nOn the other hand, server-rendered applications have been around for decades and have, until recently, struggled to match the user experience of SPAs. However, thanks to the evolution of browser standards and a crop of lightweight JavaScript frameworks, server-rendered apps have caught up and are once again a compelling option.\n\nIn this talk, we'll delve into the factors influencing the choice between SPAs and server-rendered apps. We'll discuss considerations such as:\n\n- **State Management**: Your choices affect how you'll need to manage the state of today's data-rich apps.\n- **User Experience Requirements**: Assess the application's level of interactivity and real-time updates and how well each pattern performs.\n- **Performance and Scalability**: Understanding the impact of page load times, network latency, server resources, and client resources on the application's performance.\n- **Project Constraints**: Consider time, budget, and infrastructure limitations that may influence the choice of architecture pattern.\n- **Development Team Expertise**: Evaluating the team's familiarity with JavaScript frameworks and server-side rendering.\n\nThrough practical examples and case studies, we'll demonstrate how to evaluate these factors and select the most appropriate architecture pattern for a given project. Whether you're building a content-driven website, a real-time collaboration platform, or an enterprise application, this talk will provide valuable insights to help you choose between SPAs and server-rendered apps to deliver the best possible user and developer experience.\n\n## Key Points\n\n1. Understand state management in today's data-rich applications. \n2. Explain how the microservice pattern affects pattern choice.\n3. Practical guidelines and decision-making frameworks for choosing between SPAs, HTMX, and AlpineJS based on real-world scenarios.\n4. Case studies and examples illustrating the application of each architecture pattern in different types of web applications.\n5. Tips and best practices for optimizing performance, maintaining code quality, and ensuring scalability.\n\nBy the end of this talk, attendees can confidently choose when to use a SPA or server-rendered pattern based on their project's needs and constraints. They will identify the trade-offs between complexity, performance, and user experience, enabling them to deliver high-quality web applications efficiently and effectively.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/choosing-wisely-spa-vs-htmx-for-your-next-web-project/"
+        }
+    ],
+    "speakers": [
+        "Chris May"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/nTnX_CC6cK0/maxresdefault.jpg",
+    "title": "Choosing Wisely: SPA vs. HTMX for Your Next Web Project",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/nTnX_CC6cK0"
+        }
+    ]
+}

djangocon-us-2024/videos/closing-remarks.json

@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/closing-remarks/"
+        }
+    ],
+    "speakers": [
+        "Peter Grandstaff"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/im_DZvLGd5c/maxresdefault.jpg",
+    "title": "Closing Remarks",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/im_DZvLGd5c"
+        }
+    ]
+}

djangocon-us-2024/videos/deploying-django-migrations-at-kraken-scale.json

@@ -0,0 +1,26 @@
+{
+    "description": "Kraken is an energy retail system built on Django. It is currently in use by over 20 clients around the world, including the largest energy retailer in the UK, Octopus Energy, which developed Kraken.\n\nWhen Kraken started out over 8 years ago supporting a single small client, applying Django migrations to make database schema changes was easy. Any migration that might be slightly dangerous was deployed outside business hours when the system was relatively quiet and there was no risk of disrupting the work of customer service staff. Kraken has now grown: the code has around 350 Django apps, with over 9000 migration files between them, and some database tables have billions of rows. With Kraken operating in 8 time zones around the globe, there is now no such thing as \"outside business hours\". We have needed to find other ways of deploying migrations that might be risky.\n\nThere are two main risk factors with applying migrations: taking exclusive database locks, and needing a long time to apply. Exclusive locks can interrupt normal system operations, while slow migrations can hold up the deployment process, potentially preventing later deployments for a long period.\n\nThis talk describes how we write migrations so that they avoid risks where possible, and how we deploy them in a scalable way, avoiding the need for manual intervention as much as possible. We describe techniques that use standard features in the Django migration system, as well as a system we have developed to complement standard Django migrations. The techniques described should be generally applicable to most large Django installations.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/deploying-django-migrations-at-kraken-scale/"
+        }
+    ],
+    "speakers": [
+        "Tim Bell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/6Ul-t4yw_Kc/maxresdefault.jpg",
+    "title": "Deploying Django migrations at Kraken scale",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/6Ul-t4yw_Kc"
+        }
+    ]
+}

djangocon-us-2024/videos/django-alpine-js-htmx-ups-downs.json

@@ -0,0 +1,26 @@
+{
+    "description": "A few years ago we started to hear about the toolkits htmx and Alpine.js as a powerful combination that could  be used with Django to enable development of web applications that offer user experience akin to a single page application without the overhead of adopting a heavyweight front-end framework such as React. We were excited by the promise and adopted these tools in a few projects. In this talk we'll cover:\n\n- The promise we saw in this tool combination\n- The upside: examples of exciting wins in ways of using these tools that we recommend continuing\n- The downside: some rough edges and areas of concern where we recommend caution\n- Our overall assessment and plans regarding continued use of this combination",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/django-alpine-js-htmx-ups-downs/"
+        }
+    ],
+    "speakers": [
+        "Karen Tracey"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/eyp-ArdO1Q4/maxresdefault.jpg",
+    "title": "Django + Alpine.js + htmx Ups & Downs",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/eyp-ArdO1Q4"
+        }
+    ]
+}