2.0 -//Pentabarf//Schedule//EN PUBLISH SPQP39@@pretalx.evolutio.pt -SPQP39 Programming for pleasure en en 20210602T091500 20210602T100000 0.04500

Programming for pleasure

**Why is so much software so bad?** And why is so much of it made by really excellent programmers? It's a puzzle to users, who are baffled by the way their software behaves. It's a cause of grief to customer support teams, who have to deal with users' pain. It's exhausting for product managers, who expend vast amounts of energy interacting with engineering teams. It's not just a matter of individual frustration though. Bad software emits a kind of pollution that damages working environments, and is expensive to clean up after. It's a drag on the progress of companies that use it, and harms the reputation and success of the companies that make it. So, *why do software engineering teams make bad software*, when of course they sincerely believe that they are making the best possible software, employing the best possible programmers, following the best processes? I argue that there is a reason for it: **programmers are condemned, by the nature of programming itself, to make bad software**, that we make bad software **because** programming is pleasurable. I'll discuss the consequences of this, and consider what we can do about it. And I will argue that the only way out of this fate is to embrace **pain**. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/SPQP39/ Main Room Daniele Procida PUBLISH EYKPU8@@pretalx.evolutio.pt -EYKPU8 Unlocking the full potential of PostgreSQL indexes in Django en en 20210602T100000 20210602T104500 0.04500

Unlocking the full potential of PostgreSQL indexes in Django

In the talk we are going to optimize a real life Django application using advanced and exotic indexing techinics in PostgreSQL. We are going to address performance issues in real life use cases using advanced indexing features in PostgreSQL: - B-Tree indexes - Covering indexes - Partial indexes - Function based indexes - Hash indexes - BRIN Indexes If you are not sure what are all these index types are, this talk is for you! PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/EYKPU8/ Main Room Haki Benita PUBLISH ECY3JD@@pretalx.evolutio.pt -ECY3JD Your very own real time chat with Django Channels en en 20210602T104500 20210602T113000 0.04500

Your very own real time chat with Django Channels

Does building your real time chat with Django sound fun to you? Let’s get some help from Django Channels in order to do so. In this talk I’d like to illustrate how we can use Django Channels for various purposes by showcasing its concepts and diverse use cases. This talk will cover beginner topics around Django Channels and will teach attendees the basics in order to build a simple real time chat using the library. This talk is mainly directed at beginners who are interested in learning more about Django Channels. It is expected that attendees have basic knowledge of Django (or at least Python). Some of the takeaways attendees are expected to have acquired by the end of the talk: - What is Django Channels and how does it work? - Main concepts for basic usage - How we can use the library to build cool stuff such as a real time chat PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/ECY3JD/ Main Room Amanda Savluchinske PUBLISH DMYMEE@@pretalx.evolutio.pt -DMYMEE Telepath - adding the missing link between Django and rich client apps en en 20210602T113000 20210602T121500 0.04500

Telepath - adding the missing link between Django and rich client apps

In today's web applications, the traditional client/server division is falling out of favour - there's an increasing need for the client side to handle not just the presentation layer, but the data model too. But how do you do that without recreating all of your Django business logic in JavaScript? This was the problem faced by [Wagtail CMS](https://wagtail.io/) when building a new version of StreamField, the framework for editing and organising structured page content. Our solution was a new library, '[telepath](https://wagtail.github.io/telepath/)', which can be thought of as a cross-platform version of Python's pickle mechanism, allowing arbitrary object to be unpacked into JavaScript code. In this talk, we'll show how Wagtail has used telepath to enhance Django forms with new client-side capabilities, and how you can use it in your projects to get the best of both the server-side and client-side world. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/DMYMEE/ Main Room Matt Westcott PUBLISH PC7PZP@@pretalx.evolutio.pt -PC7PZP (A) SQL for Django en en 20210602T121500 20210602T130000 0.04500

(A) SQL for Django

This talk will show you how to combine SQL and ORM in Django applications. Both ORM methods and SQL have their place. ORM and Django's model classes give us a great development experience. We get an easy-to-use and powerful way to define, migrate, and use our database. SQL gives us access to all the features our database has to offer. It The talk will be structured as follows: - Why care about SQL? - Working with data in Django - Common ORM use cases - Creating complex queries: Q, F, annotations - Creating and Addressing the N+1 query problem with Django ORM. - Everything works, so why use SQL? - Minimize Database access for maximal Performance - Use Features of complex sequel queries; Sub-Selects - Benefit from the SQL Know-How and documentation - Best of both worlds: Getting objects with raw queries - If all else fails: Directly using database connections for updates and analytics - Drawbacks of SQL in Django - Review: SQL, Django - How and Why PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/PC7PZP/ Main Room Stefan Baerisch PUBLISH TZ8E7H@@pretalx.evolutio.pt -TZ8E7H KEYNOTE | How to be a djangonaut in a climate emergency en en 20210602T135000 20210602T150500 1.01500

KEYNOTE | How to be a djangonaut in a climate emergency

PUBLIC CONFIRMED Keynote https://pretalx.evolutio.pt//2021/talk/TZ8E7H/ Main Room Chris Adams PUBLISH NBUHRU@@pretalx.evolutio.pt -NBUHRU Full-stack Django Rest Framework en en 20210602T150500 20210602T155000 0.04500

Full-stack Django Rest Framework

In this talk, we want to share our experience going beyond JSON APIs and using more Serializers and Renderers' features to create full-stack applications using Django Rest Framework. After many years using only Django and creating many applications with the traditional HTML templates and forms, like most web developers, we started to go more and more into a separate solution of backend and frontend. To do that, we then used Django Rest Framework to create nice JSON APIs. But recently, we started to go back to our roots and create more full-stack applications, but using Rest Framework to get the most of both worlds. Our views now not only can render HTML templates and serializers as forms but also, with the support of Renderers, allow us to quickly have JSON and more complex formats like Microsoft Word or Excel document responses. With that, we can render our HTML templates in the backend but already have the same serializers to update our DOM dynamically or download the same data as a report. It wasn't as easy as we thought, and we needed to learn a lot during the process, creating our own solutions and extending some parts of Rest Framework itself. We want to share all of that and maybe help you too. Photo by [Bekir Dönmez](https://unsplash.com/@bekirdonmeez?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/NBUHRU/ Main Room Thiago Garcia da Silva Israel da Silva Teixeira PUBLISH F9J8CU@@pretalx.evolutio.pt -F9J8CU Writing Safe Database Migrations en en 20210602T155000 20210602T163500 0.04500

Writing Safe Database Migrations

Django’s built-in migration framework is great. And it works tremendously. But that’s only on the surface. Whenever you deploy your code and apply migrations in production, you are about to enter dangerous territory. I will point out common pitfalls and show you ways to avoid them. And with some additional best practices at hand, you will be ready for your next production deployment. The talk slides are available on [**Speaker Deck**](https://speakerdeck.com/markush/writing-safe-database-migrations-djangocon-europe-2021). PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/F9J8CU/ Main Room Markus Holtermann PUBLISH PLFDVE@@pretalx.evolutio.pt -PLFDVE Hunting Performance in Django Code en en 20210602T163500 20210602T172000 0.04500

Hunting Performance in Django Code

Introduction and Outline Quick introduction of myself followed by an outline of what will be covered and what you will learn. Why we profile? A typical program spends almost all its time in a small subset of its code. Optimizing those hotspots is all that matters. This is what a profiler is for: it leads us straight to the functions where we should spend our effort. What types tools are available and how they work? -Deterministic Profilers -Statistical Profilers I will be walking over the different use cases, pros/cons for each type. Then I will dig in a bit deeper on how they work under the hood. Understanding the inner workings a bit might be helpful while analysing its output. What kind of information do we get? I'll describe what kind of output we get from different profilers. What kind of metrics are available(Wall time, CPU time, sub/cumulative time) and where are those metrics are most useful while hunting for performance problems especially for Web applications. I will also walk over/explain different kind of visualisations that profilers generate: Flamegraphs, Callgraph, SpeedScope...etc. Questions PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/PLFDVE/ Main Room Sümer Cip PUBLISH JM9UY7@@pretalx.evolutio.pt -JM9UY7 Domain Driven Design with Django and GraphQL en en 20210602T172000 20210602T180500 0.04500

Domain Driven Design with Django and GraphQL

Domain driven design is starting getting traction in the Python world, probably also thanks to Architecture Patterns with Python (https://www.cosmicpython.com/). In this talk we will learn some basics of Domain Driven Design and how to apply the pattern when using Django and GraphQL. We will see different approaches of modelling the domain, and discuss the tradeoffs. We will discuss why this approach makes a lot of sense with GraphQL and finally we will see a complex approach where we leverage the domain driven architecture to have an easy way to abstract how we store and cache our data in order to build a performant GraphQL API. This talk is aimed at people with knowledge of web-development. GraphQL knowledge won’t be necessary as I’ll do a quick introduction of that. Experience with Django, Flask or similar framework might be useful but not required. The audience will learn basic concepts of domain driven design and how to apply them to build a scalable GraphQL API. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/JM9UY7/ Main Room Patrick Arminio PUBLISH LMWU8L@@pretalx.evolutio.pt -LMWU8L Getting started with React, GraphQL, and Django en en 20210602T094500 20210602T103500 0.05000

Getting started with React, GraphQL, and Django

When I first heard of GraphQL, I had a lot of questions. How is GraphQL different from REST? What're the benefits? When would I use it instead of DRF (Django Rest Framework)? Can I use it with my existing Django models? What about my views? My permissions? Is it difficult to integrate with my frontend? REST has served us well for more than twenty years; of course, I would be wary of any technology which requires a total paradigm shift. In this session, I will answer those questions and hopefully alleviate any apprehension about trying GraphQL. We'll look at a working example of an RGD stack, showing how you can continue to use all the power of your Django backend while rendering and querying your data in React via GraphQL. PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/LMWU8L/ Secondary Room Aaron Bassett PUBLISH YXVTVE@@pretalx.evolutio.pt -YXVTVE Teaching cPython, Turtle Graphics, and Jinja2 in the Browser en en 20210602T120000 20210602T125000 0.05000

Teaching cPython, Turtle Graphics, and Jinja2 in the Browser

There are many excellent [free resources for learning Python](https://www.reddit.com/r/learnpython/wiki/index), but the [Forest Wiki](https://ForestWiki.com) is the only free resource for teaching Python, Jinja2 and web development in the browser.  The Forest Wiki understands and respects the relationship between the teacher and a class of students.   Here is [the demo for teaching turtle graphics]( https://demo.forestwiki.com/spiral). Here is [the cPython in the Browser Demo](https://demo.forestwiki.com/cPython/aceedit). The teacher sets the assignments, the students do them.   Even when the students are working from home, the teacher can monitor their progress. If there is an issue, or during grading,  the teacher can privately comment on that student's work.    When the time is right, the teacher can check a box to publish the answers.  When the time is up, the teacher can check another box to limit new submissions. Just to be clear, this tutorial is not about teaching you Python and web development. It is about training the teachers. It is assumed that you already know some Python and HTML. And yes, you will learn some Turtle graphics and Jinja2. But in the class the focus will be on teaching someone else. We will break out into groups of 2 and take turns being the teacher and the student. No need to install anything for this class. All exercises will be done in the browser using Skulpt, and Pyodide (cPython 3.8.2 running on WASM). The whole point of teaching in the browser, is that your students will also not need to install anything. PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/YXVTVE/ Secondary Room Christopher Lozinski PUBLISH UQVXM9@@pretalx.evolutio.pt -UQVXM9 Django Sketchnoting Challenge en en 20210602T153000 20210602T162000 0.05000

Django Sketchnoting Challenge

In this workshop we will learn some easy drawing skills we can use for illustrating tech concepts (or anything else). Sketchnoting, the combination of text and simple, symbolic drawings is a great way to express ideas. Requirements, user stories, notes of meetings, talks, articles or tutorials, all can become much more engaging with a few extra illustrations. Though developers (and people in general) often think they can't draw, there are some easy tricks everyone can learn. In addition, drawing things is a really fun way to spend your time! After a short intro of what sketchnoting is (5 min), we go over 4 tips for sketching practice: * I can't draw this: composition and googling (5 min) * drawing people fast and easy (5 min) * putting text in boxes (5 min) * faces and emotions (5 min) We will continue with a couple of drawing challenges (10 min), where I will show how to quickly sketch some easy and more difficult concepts. The last 25 minutes will encourage the attendees to illustrate a Django concept on their own, with guidance and support from myself. This can be the take aways of a Djangocon talk, a concept they recently learned, an illustration to a blogpost or podcast, tips on how to make the most out of an online conference... This workshop intends to appeal to an audience of all backgrounds and skill levels. On top of that, the content will be appropriate for all ages, so you can draw along with your kids! By the end of this talk, attendees will have some inputs to be creative with pen and paper, and have learned some of the skills that go with it. PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/UQVXM9/ Secondary Room Sara Peeters PUBLISH YY3LBL@@pretalx.evolutio.pt -YY3LBL Dynamic static sites with Django and Sphinx en en 20210603T091500 20210603T100000 0.04500

Dynamic static sites with Django and Sphinx

On a content site these days, especially on a personal project, or where the team are technical, you often don't want the limitations and complexity of full CMS. No, you want to use familiar tools: you want to write in Markdown and manage your content in git. That doesn't necessarily fit the traditional Django workflow. You end up looking at a static site. This is fine but you loose the ability of Django to serve dynamic pages. You have to decide which of the numerous generators you're going to use, or whether indeed you'll roll your own. It's a bit of a mess. You can have the best of all worlds though. Sphinx, yes the documentation builder, is a super capable static site builder. You can use it to build your content. Yes it can handle Markdown. Then you can use Django to serve that content, given auth, forms, interactivity, custom content, and all the rest of it. I'm going to show you how. The talk has two parts: Sphinx and then Django. * First we'll introduce using Sphinx to manage and build your content. * We'll look at project setup so you can use Markdown for files. * We'll organise those on the file system, and use git to manage them, rather than a full-blown CMS. * We'll push to GitHub and use a GitHub Action to build on each commit. * Then we'll setup Django to serve our Sphinx built content. * We'll use the DTL to get control over our templates. * And we'll add auth, to provide dynamic per-user content. From there, the sky's the limit. Content management never looked so rosy. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/YY3LBL/ Main Room Carlton Gibson PUBLISH KXQPUU@@pretalx.evolutio.pt -KXQPUU Anvil: Full Stack Web with Nothing but Python en en 20210603T100000 20210603T104500 0.04500

Anvil: Full Stack Web with Nothing but Python

Building a modern web app requires *so much*: HTML, CSS, JS, Python, SQL, React, Bootstrap, Webpack...and Django, of course ;). What if we could build a better abstraction? Our answer is Anvil: a full-stack Python environment where everything is a Python object, from your UI components to your database rows. In this talk, I'll walk you through how and why we constructed this new approach to the web. We'll start with a question: Why is web programming hard? It's because your data takes so many forms: database rows, Python objects, JSON on REST, JS objects, HTML DOM, and finally pixels. Most of a web developer's job is translating between these awkwardly different representations. Frameworks like Django help, but now you have a stack of leaky abstractions: web frameworks, ORMs, JS frameworks, CSS frameworks, build tools... These frameworks help you go faster, but they double the amount you need to know! So I'll show our stab at an answer: A framework where everything is a Python object, requests to the server are function calls, and Python is a browser-side language. I'll talk about running Python in the browser. I'll talk about full-stack autocompletion. There will even be live coding. And then I'll talk about how it breaks. Because every abstraction breaks, and this abstraction is bigger than most. So I'll touch on what it means to go down with the ship, to use an ejector seat, or to open an escape hatch. Join me for a rollicking tour of a new way to approach the web! PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/KXQPUU/ Main Room Meredydd Luff PUBLISH VYNPNR@@pretalx.evolutio.pt -VYNPNR Hacking Django Channels for Fun (and Profit) en en 20210603T104500 20210603T113000 0.04500

Hacking Django Channels for Fun (and Profit)

- Intro and Backstory on Django Channels history — 3% - Synchronous vs Async Request Loops - WSGI vs ASGI for your Django Application - Intro to WebSockets — 3% - Demo of them used in the real world web applications - How they interact with async event loops - Django Channels Core Concepts — 10% - Consumers - Channel Layers - Background Workers - Consumers and ASGI Routing Example — 10% - Where to Background Workers Fit? — 10% - Lightweight Tasks - Considerations when reliability is not needed - How about reversing the Consumer use case? — 20% - Create long-running Background Workers - Connect to remote services such as Discord to create Bots - Example application integration with Discord — 20% - Connect to Discord on start and listen for messages and other events - Send our own application messages into Discord - Building your own long-running Channel Worker — 20% - What to add to your project - Define channel background tasks to run at start - Next steps for this project — 2% - Upstream or create Channels addon to make this functionality more generic - Add ability to define one-shot tasks - Add ability to define post-job tasks to run on stop - Conclusion — 2% PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/VYNPNR/ Main Room Calvin Hendryx-Parker PUBLISH F7EZXH@@pretalx.evolutio.pt -F7EZXH Modern JavaScript for Django Developers en en 20210603T113000 20210603T121500 0.04500

Modern JavaScript for Django Developers

The talk will include four high level parts. Part 1 is a discussion of common Django / JavaScript architectures. These include: 1. The most common "ad-hoc" approach, where JS just gets incrementally added to templates until you find yourself in a mess 2. The "completely decoupled" JS front-end and Django-API back end, which is popular, but complex and unfamiliar to pure Django developers. 3. A "hybrid architecture", that combines modern JS with familiarity of working in Django. Part 2 will focus on the fundamentals of JS tooling - a prerequisite to working with modern JavaScript. I'll start with explaining why it's so frustrating and confusing trying to add React to a Django project. Then introduce the concept of a JavaScript toolchain. Why you need them and what they do. And finally do a quick overview of the most common JS toolchain: NPM, Webpack, and Babel, including what each does and the analogies in the Python world. Part 3 brings it together with a Django example, deep diving into how you can add a JS toolchain to a DJango project and introduce a React application into a Django application without all the complexity of managing separate standalone front end. Part 4 will briefly touch on some benefits of Modern JS, including using modern frameworks, dependency management, new features, extensions, ES6, React and JSX, Vue etc. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/F7EZXH/ Main Room Cory Zue PUBLISH NCTBUS@@pretalx.evolutio.pt -NCTBUS Clean Architecture with Django: Rethinking basic assumptions en en 20210603T121500 20210603T130000 0.04500

Clean Architecture with Django: Rethinking basic assumptions

Clean Architectures and related architecture patterns like Hexagonal and Onion architecture are intended to provide more maintainable code and lower technical debt. Two parts of Django's architecture, the Django ORM and 3rd party Django REST Frameworks, make it difficult to get the benefits of a Clean Architecture. We look at ways we can achieve the benefits of Clean Architecture (CA) while using the Django framework. What are the various Clean Architecture Patterns and what do they promise to do for you? What is the ideal architecture pattern that Django supports? Problem 1: most Object Relational Mappings including Django's do two things: 1) Specify the persistence model: normalisation of data, efficient storage, efficient lookup, etc. 2) Specify the business entity domain: what business objects does the domain manage The problem is that these are two different goals handled in one framework component, the ORM. Problem 2: REST frameworks have a heavy reliance on the ORM. This ties together the business domain to storage semantics making it hard to achieve some of the benefits of a Clean Architecture. Two solutions paths exist: Django can serve a clean architecture-like paradigm, under specific circumstances. But there is some confusion about what CA looks like in practice that causes developers to go for solutions that are the opposite of CA. The other solution is a more fundamental rethink of how to implement and use ORMs and REST frameworks (including remote request frameworks like GraphQL). PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/NCTBUS/ Main Room Paul Wolf PUBLISH VCTVRB@@pretalx.evolutio.pt -VCTVRB KEYNOTE | Spreading our tentacles - taking a Django app global en en 20210603T135000 20210603T150500 1.01500

KEYNOTE | Spreading our tentacles - taking a Django app global

PUBLIC CONFIRMED Keynote https://pretalx.evolutio.pt//2021/talk/VCTVRB/ Main Room Frederike Jaeger PUBLISH PZ3KWB@@pretalx.evolutio.pt -PZ3KWB HTMX: Frontend Revolution en en 20210603T150500 20210603T155000 0.04500

HTMX: Frontend Revolution

I developed my first CGI script in 1998. Since that day I have seen a lot of hypes coming and going. The talk will consist of three parts: * My humorous odyssey of trying to find a great frontend framework * Retrospective: What do I want from the frontend? * I finally found: HTMX: HTML Fragments over the wire Besides simplicity, good Web Vitals performance (SEO) is a benefit of this method. The talk will express my personal opinion, feelings and fun. It won't dive into technical details. Thank you to https://www.djangsters.de for supporting the talk. Slides: https://docs.google.com/presentation/d/1Gx1UGVAgD2ALLOucsIm9myF5mDflbP06-M6_d-RdZAY/edit?usp=sharing Example Project: https://github.com/guettli/django-htmx-fun PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/PZ3KWB/ Main Room Thomas Güttler PUBLISH RE7AVL@@pretalx.evolutio.pt -RE7AVL You might not need a frontend framework en en 20210603T155000 20210603T163500 0.04500

You might not need a frontend framework

Javascript fadigue is real. As frontend development gets more and more complex, developers are required to learn a wide plethora of languages and tools to bring reactivity to their web apps. Introducing a SPA framework into a Django project can bring a lot of complexity to the codebase, requiring context switching between two different languages (Python and Javascript) and expertise into a wide set of tools, like `node`, `npm`, `webpack` and `babel`. Accessibility and SEO can also be affected by the introduction of a SPA architecture. In this presentation I am going to talk about taking a step back in front-end development and carefully weighting the pros and cons of introducing a Javascript framework into a Django project. I will also show some examples of how to progressively enhance a web page, adding reactivity while maintaining the accessibility. We will explore some libraries like [htmx](https://htmx.org/), [hotwire](https://hotwire.dev/) and [alpinejs](https://github.com/alpinejs/alpine) that can help keeping the frontend light and lean. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/RE7AVL/ Main Room Afonso Cerejeira PUBLISH DXMJ8H@@pretalx.evolutio.pt -DXMJ8H Django with PostgreSQL superpowers en en 20210603T163500 20210603T172000 0.04500

Django with PostgreSQL superpowers

Every time we’re going to create a new project with **Django** we make assessments on its requirements to choose the best architecture, of which, the **database** is usually the core. Django is a _database-agnostic_ web framework but natively supports only 4 **open source** databases: PostgreSQL, SQLite, MariaDB and MySQL. **PostgreSQL** has the _richest feature set_ of any supported database and some of these features are natively supported directly in Django via its contrib module. In this talk we’ll see how to use to our _advantage_ the features of PostgreSQL as a database in Django, its exclusive features present in its _contrib module_ and also other **superpowers** that can be exploited through the use of _third-party packages_. --- More info and slides: **https://www.paulox.net/2021/06/03/djangocon-europe-2021/** PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/DXMJ8H/ Main Room Paolo Melchiorre PUBLISH FJLKVT@@pretalx.evolutio.pt -FJLKVT How to create a full-stack, reactive website in Django with absolutely no JavaScript en en 20210603T172000 20210603T180500 0.04500

How to create a full-stack, reactive website in Django with absolutely no JavaScript

Django is a great web framework for "perfectionists with deadlines" and provides a lot of built-in functionality when building server-side websites. However, a lot has changed on the web since its inception in 2005, and now it has become somewhat common advice for modern web applications to only use it as an API backend, if at all. However, there are a few Django packages that enable building a reactive website while still utilizing all of the strengths of Django. This talk will cover the benefits of this approach, a brief overview of how other programming languages are solving this same problem, and a few Django projects which can help developers build interactive websites without writing any custom JavaScript. Repository with example code, slides, and a transcript: https://github.com/adamghill/djangocon-eu-2021-conference-talk. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/FJLKVT/ Main Room Adam Hill PUBLISH VJD9VP@@pretalx.evolutio.pt -VJD9VP Profiling Django & Python apps en en 20210603T094500 20210603T103500 0.05000

Profiling Django & Python apps

Sponsored by Blackfire.io PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/VJD9VP/ Secondary Room Jérôme Vieilledent Sümer Cip PUBLISH RW9FVH@@pretalx.evolutio.pt -RW9FVH Django Unstuck: Suggestions for common challenges in your projects en en 20210603T120000 20210603T125000 0.05000

Django Unstuck: Suggestions for common challenges in your projects

In this workshop, we are going to look at four challenges that appear in every Django project at some point. We are going to analyse what's happening, what you can do to get un-stuck, and see what other people do. This workshop is for beginners and advanced Django users. The issues we discuss appear in many Django projects, so there is something here for every level of Django knowledge. These are the four challenges we are going to look at: * App management and placement (and urlpatterns) * Templates: Placement, folders, blocks and inheritance and namespaces * When to use Middlewares and context processors and what are they? * Should code/logic go into models, views or managers or somewhere else? For each of these, we will try out what **I** do when they happen, and we'll discuss other strategies. We will not do a lot of coding in this workshop, but if you want to follow along, make sure you have Django installed and can execute "django-admin.py". There is also a set of base templates I am going to use for illustration, which is linked in the files below. Of course, there are many more problems like these, which is why I made a list of "suggestions" or "best practices" for these and others. Here's what we're working on so far: * App management and placement (and urlpatterns) * Splitting settings: local, dev, testing and production * Username vs email address * Registration in general * Background tasks and long-running processes and Caching * Templates: Placement, folders, blocks and inheritance and namespaces * Should you do i18n and l10n right away? * When and how to start caching (memcached, redis etc.) * Should code/logic go into models, views or managers or somewhere else? * When to use Middlewares and context processors and what are they? * How to secure access: security middlewares or login_required (white vs black list) * How to create files and store them in file models * What to do about image scaling and thumbnailing (and hosting)? * How to serve content: coded pages, flatpages or Wagtail? You can find that list on Github at: https://github.com/shezi/django-unstuck (it's a work-in-progress). There is also a Discord community and Telegram chat group surrounding that list, so if you have any kind of problem with a Django project, come join us and we'll find a way to get you unstuck. We're building a community around Django best practices and on getting you Unstuck in challenging situations. Join us on Discord at https://discord.gg/bUsu9B6Ek6 or on Telegram at https://t.me/djangoRhein About me: I'm Johannes Spielmann, software developer-for-hire from Germany, and I've been doing Django projects for almost 15 years, ever since I saw Adrian Holovaty's presentation at "Snakes and Rubies". I've done projects both small and large, both in commercial and non-commercial settings, and I've seen all of the above things many times. **You can find all materials for this talk also at: https://shezi.de/djangocon.eu.2021/** PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/RW9FVH/ Secondary Room Johannes Spielmann PUBLISH CTXYZE@@pretalx.evolutio.pt -CTXYZE Managing multiple Django services in a single repo en en 20210603T153000 20210603T162000 0.05000

Managing multiple Django services in a single repo

Modern software systems often involve developing and deploying multiple related services. The microservice architecture is a prominent example of this. These services often share underlying data structures, models, utilities, protocols and other core code. Django is an excellent choice for building individual services, and some functionality can be shared between them by reusing apps. But Django projects themselves are standalone by nature, and there is no standard infrastructure for streamlining the management many related services. As a result we're often forced to treat each project as an island, with its own settings and deployment configuration, possibly in its own repo. In this workshop we will demonstrate: - The challenges of maintaining many interrelated Django projects. - The advantages of having multiple Django projects coexist in a single shared repo. - The tooling you need to work effectively in a Django monorepo, with a focus on the Pants build system. - Specific examples of good practices that allow you to maintain a growing yet streamlined stable of interrelated Django-based microservices with minimal boilerplate and copypasta. Code along with us, and ask questions along the way! PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/CTXYZE/ Secondary Room Benjy Weinberger PUBLISH UBAQPR@@pretalx.evolutio.pt -UBAQPR Deploying a Django Virtual Event Platform Using Containers and Terraform en en 20210603T170000 20210603T173000 0.03000

Deploying a Django Virtual Event Platform Using Containers and Terraform

- Intro to Cloud Native deployment — 10% - Hitchhikers Guide to Cloud Native vocabulary - Laying the groundwork for going Cloud Native — 10% - Containerizing your app - Preparing your image for production - Building the pipeline — 20% - Sketching out your infrastructure - Moving to Terraform - Creating a CI/CD workflow - Playing with Building Blocks — 20% - Leveraging AWS Cloud Components for Delivery - Using Environment Variables and keeping Secrets - Scaling Considerations, Load Balancers and CDNs — 20% - Many routes behind one URL - Enable effective caching - Keep things on a need to know basis (only pass what you need) - Load Testing — 10% - Build test plans with Locust.io (Python powered!) - Testing and debugging load tests with remote PDB - Conclusion — 10% Sponsored by Loudswarm PUBLIC CONFIRMED Other https://pretalx.evolutio.pt//2021/talk/UBAQPR/ Secondary Room Calvin Hendryx-Parker PUBLISH NS9S7N@@pretalx.evolutio.pt -NS9S7N Speed up your tests with setUpTestData en en 20210604T091500 20210604T100000 0.04500

Speed up your tests with setUpTestData

TestCase.setUpTestData allows you to create test data once per TestCase, rather than once per test. Switching tests to use setUpTestData rather than setUp can speed them up significantly, sometimes as much as 10x faster. This talk will cover how it works, its improvement in Django 3.2, and how to convert your tests to use it. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/NS9S7N/ Main Room Adam Johnson PUBLISH QQJ9WB@@pretalx.evolutio.pt -QQJ9WB Rewriting Django from (almost) scratch in 2021 en en 20210604T100000 20210604T104500 0.04500

Rewriting Django from (almost) scratch in 2021

One of the decisions that was made 15 years ago was to use *home-made* code for everything. Django depends on very few libraries. Django doesn't use anything from the Python eco-system, when it comes to ORM, templates, routing, etc. And that is a decision I would probably have done at the time as well. The Python world was much less welcoming at the time and documentation was still regarded as a second-class citizen. Let's not even mention the wrath you were taking the risk of exposing yourself to if you dared make a pull request on a project you weren't involved with. Those choices are not the only reasons to consider a rewrite though... After attending several Django conferences, I noticed a few trends about what prominent Django developers would like to change. For example **WSGI middlewares** is something that's often put on the table, **websockets** is another of those things that comes up very often. It is true that the world of the web is quite different today compared to what it was 15 years ago. It seems to me that today **REST API's** and **websockets** are first class citizens while server-rendered pages have become less important. Once again, that's just a personal feeling. A complete Django rewrite is also not my very own idea, several people have been working on a similar idea. Tom Christie has been working on many libraries in order to be able to rewrite Django as an async framework in order to better accommodate websockets. Others like Tobias have been working on something similar but starting at the other end of the problem. I guess this is just my own version of that thought experiment. For this thought experiment I will care about retaining the "spirit" of Django as I perceive it but I will not care at all about backward compatibility! ## What does a Django rewrite needs to achieve in 2021? - Batteries included: Anything that claims to be a Django-like needs to come with everything out of the box - A friendly ORM with a syntax that is closer to the objects than to SQL - Middlewares - Sessions - Authentication and authorization - Routing - Easy to build REST API's - Websockets - Template-based rendering - Static files serving during development - Easy documenting of API's - MVC implementation - Easy to use CRUD controller and associated views - A powerful admin(based on its own CRUD controllers) - Error management This talk will cover all of those points, how they could be approached and whether using an existing Python library for that job might be a good idea **Code:** - [Cordy](https://gitlab.levitnet.be/levit/cordy/-/tree/master) - [CookieCutter for starting a project](https://gitlab.levitnet.be/levit/cordy-project/-/tree/master) - [Demo app (Splendid)](https://gitlab.levitnet.be/emma/splendid/-/tree/master) **Demo:** https://levit.be/uploads/Kazam_screencast_00003.mp4 **Slides:** https://slides.com/emma_be/cordy PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/QQJ9WB/ Main Room Emma Delescolle PUBLISH LKQSE7@@pretalx.evolutio.pt -LKQSE7 Get interactive! Putting a shell (or a desktop) in your Django app en en 20210604T104500 20210604T113000 0.04500

Get interactive! Putting a shell (or a desktop) in your Django app

In our [City Cloud Academy](https://academy.citycloud.com) learning platform, we enable learners to interact with real-world hands-on lab environments, so that they can learn complex technologies like OpenStack, Kubernetes, Terraform, Ceph, Ansible, and others. To do that, we use [Apache Guacamole](https://guacamole.apache.org/)'s `guacd` service to provide learners with interactive shell terminals — or even full desktop environments — that run right in people's browsers, no additional software required. The Guacamole platform is normally deployed in conjunction with [a Java servlet environment](https://guacamole.apache.org/doc/gug/guacamole-architecture.html#web-application) (commonly Apache Tomcat). But the Guacamole protocol is not tied to the Java language in any way, and a Python websocket proxy ([pyguacamole](https://pypi.org/project/pyguacamole/)) is readily available under an open source (MIT) license. In this talk, we discuss how we implemented a learning platform (based on [Open edX](https://open.edx.org)) that deploys an ASGI service under [Daphne](https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/daphne/), uses pyguacamole to provide an asynchronous websocket connection to a Guacamole service, and thus creates a highly scalable, interactive, and immersive learning environment that helps people learn complex technology with no hardware or cloud investment at all. ## Slides The slides (with full speaker notes) are up at <https://fghaas.github.io/djceu2021/> and <https://mrtmm.github.io/djceu2021/>. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/LKQSE7/ Main Room Florian Haas Maari Tamm PUBLISH GWVRVA@@pretalx.evolutio.pt -GWVRVA Build, deploy and scale: Django, GraphQL and SPA en en 20210604T113000 20210604T121500 0.04500

Build, deploy and scale: Django, GraphQL and SPA

After building, deploying and scaling a dozen on products with the Django + GraphQL + SPA (React) setup, we have come to understand what works and what does not. In this talk, I will share our findings on how to do the same. I will be using a simplified StackOverflow clone for demonstration. First, I will introduce Python-Graphene (and few other related libraries), the library that is used to build GraphQL endpoints. Then the talk will focus on how to structure your Django GraphQL project. Share the toolchain (a few management command scripts) that are handy to export your constants & GraphQL schemas to be used with your SPA. Integrating with an SPA (React for demo purpose) Auth, API calls. Then I will talk about how you go about deploying your API using 2 different strategies: 1. Docker compose / swarm (Vendor independent, non-production workloads) 2. AWS Fargate (Vendor dependant, production workloads, serverless containers) And a cost-effective and highly scale-able deployment strategy for your SPA (using AWS S3, CloudFront and ACM). PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/GWVRVA/ Main Room dhilipsiva PUBLISH TXENJP@@pretalx.evolutio.pt -TXENJP Load Testing a Django Application using LocustIO en en 20210604T121500 20210604T130000 0.04500

Load Testing a Django Application using LocustIO

Fed up of using existing tools for determining benchmark and doing load testing for your server application? LocustIO is present to the rescue. LocustIO is an easy-to-use, distributed, user load testing tool. It is intended for load-testing web sites (or other systems) and figuring out how many concurrent users a system can handle. Using Locust you will be able to determine the system performance at different endpoints in very simple and efficient way. This will provide you a rough idea on how many requests per second is supported by your application. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/TXENJP/ Main Room Pranjal Jain Vibhash Chandra PUBLISH SDMA7T@@pretalx.evolutio.pt -SDMA7T KEYNOTE | We're all part of this: Jazzband 5 years later en en 20210604T135000 20210604T150500 1.01500

KEYNOTE | We're all part of this: Jazzband 5 years later

PUBLIC CONFIRMED Keynote https://pretalx.evolutio.pt//2021/talk/SDMA7T/ Main Room Jannis Leidel (he/him) PUBLISH 7B9YYD@@pretalx.evolutio.pt -7B9YYD The request/response cycle - a Djangonautic journey en en 20210604T150500 20210604T155000 0.04500

The request/response cycle - a Djangonautic journey

How exactly do web-servers communicate with Django? and what happens immediately after that? If you've ever wondered where the `request` object comes from? How the middleware-chain is put together? Or just what all those functions you see in your exception tracebacks do? Then join me in a deep dive of everything between the server, the view and back again, as we answer these questions and more. This talk will be a look under the hood at Django's request handlers, middleware-chain and URL-resolvers. Focusing on just the WSGI route (not asynchronous), it aims to be accessible to beginners, but with the intention that a more experienced user will learn something new or interesting as well. We will start off by replacing Django's `WSGIHandler` with our own "hello world" WSGI application. We'll then build back in additional features until it starts to resemble what we originally had. Along the way, we'll highlight lesser-known features, and give examples demonstrating how understanding the implementation will enable you to better take advantage of the features Django offers, and ultimately write better code. PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/7B9YYD/ Main Room Timothy McCurrach PUBLISH APN93S@@pretalx.evolutio.pt -APN93S All about The Django Software Foundation (DSF) en en 20210604T155000 20210604T163500 0.04500

All about The Django Software Foundation (DSF)

DSF SLOT PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/APN93S/ Main Room Anna Makarudze PUBLISH E8AYPU@@pretalx.evolutio.pt -E8AYPU Serving Files with Django en en 20210604T163500 20210604T172000 0.04500

Serving Files with Django

The fairly new support for real async views (since Django 3.1) opened up a lot of new possibilities. I was so excited about them that I wrote a longish blogpost about the topic: [Django 3.1 Async](https://wersdoerfer.de/blogs/ephes_blog/django-31-async/) This article was also published on paper in a german developer magazine: [Django wird asynchron](https://kiosk.entwickler.de/entwickler-magazin/entwickler-magazin-6-2020/django-wird-asynchron/) Back then I had trouble to come up with a compelling use case for those new async views. But now I believe file serving is one of them. Usually you would use nginx in front of your Django application servers, a CDN or just S3 / another object store. But let's face it: This will add another layer of architectural complexity and authentication/authorization will be a real PITA. And some things might get a lot easier with pure Django file serving - let's assume I want to know how long people listened to my podcast delivered via http live streaming on average. If the media file was delivered via Django, it would be possible to log those numbers directly in the App. Otherwise you would have to calculate them from aws access log files or something like that (good luck with that). So, using nginx will probably be still faster and you won't be able to saturate 100Gbit/s. But maybe you don't need to and Django alone is already fast enough. Until june I probably have some benchmarks to prove it or a story about an embarrassing failure :). PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/E8AYPU/ Main Room Jochen Wersdörfer PUBLISH NUKNRB@@pretalx.evolutio.pt -NUKNRB Securing Django Applications en en 20210604T172000 20210604T180500 0.04500

Securing Django Applications

Django is the most popular Python-based web framework used for creating web applications. The web applications are vulnerable for various reasons including a) configuration settings of the web applications b) lack of implementation of security best practices and secure coding and c) lack of awareness of secure first web applications among developers. The vulnerable web applications put the data of the customers at greater risk and the compromised code can lead to problems beyond control. It is very important to develop secure web applications to protect customer data and code to mitigate the risk. In this talk, we will focus on two aspects. First, performing penetration testing on Django web applications to identify vulnerabilities and scanning for Open Web Application Security Project (OWASP) Top 10 risks. Second, strategies and configuration settings for making the source code and Django applications secure. We will also discuss the Djangohunter tool to identify incorrectly configured Django applications that are exposing sensitive information. Outline 1. Security aspects of Django web applications (03 minutes) 2. Penetration testing of Django web applications (07 Minutes) 3. Overview of OWASP Top 10 risks (07 Minutes) 4. Djangohunter tool demonstration (06 Minutes) 5. Strategies and configuration settings to make Django Application secure (07 Minutes) PUBLIC CONFIRMED Talk https://pretalx.evolutio.pt//2021/talk/NUKNRB/ Main Room Gajendra Deshpande PUBLISH VHFEDF@@pretalx.evolutio.pt -VHFEDF Migrations and understanding Django's relationship with its database en en 20210604T094500 20210604T103500 0.05000

Migrations and understanding Django's relationship with its database

Slides: https://drive.google.com/file/d/13wsg1yYWX0aJrLuA4a-GRnej42GBN1CK/view?usp=sharing **Description** Migrations are a very convenient aspect of the Django framework. They allow making changes to your models when needed, and impact the database schema iteratively in a smooth and integrated manner. No need to have a deep knowledge of SQL, be a database expert nor administrator - it just works. Or at least, most of the time. The generated migration files reflect the model changes from one version to the next, and Django logically expects these migrations to be applied for the database connections to work. The required synchronicity between code and database schema is the root of some issues one might encounter when using Django. We will dive into these issues during this workshop. We will first explore in which cases one can run into these migration problems, and how they are intrinsically linked to this synchronicity. This will be done by creating a Django project and adding toy features to it, like any developer would do during the workday. After defining the concept of backward incompatible migrations, we will also expose some example operations and why they can turn out dangerous. The workshop will go about suggesting some existing solutions to these problems: we will manually fix such an issues in development, but also explore how to prevent them from happening in a large-scale infrastructure with multiple servers. Hopefully giving the attendees a better grasp of what is happening under the hood when something seems off with models and migrations. **Workshop preparation** Get the toy project up and running => clone and install https://github.com/David-Wobrock/djangocon-europe-2021-migrations-workshop PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/VHFEDF/ Secondary Room David Wobrock PUBLISH SXFXBF@@pretalx.evolutio.pt -SXFXBF Cleanroom Software Engineering with Django en en 20210604T120000 20210604T125000 0.05000

Cleanroom Software Engineering with Django

The Software Engineering Institute defines the Cleanroom software engineering as "a theory-based team-oriented process for development and certification of high-reliability software systems under statistical quality control. A principal objective of the Cleanroom process is development of software that exhibits zero failures in use. The Cleanroom name is borrowed from hardware Cleanrooms, with their emphasis on rigorous engineering discipline and focus on defect prevention rather than defect removal. Cleanroom combines mathematically based methods of software specification, design, and correctness verification with statistical, usage-based testing to certify software fitness for use. Cleanroom projects have reported substantial gains in quality and productivity. " This method was widely adopted in the 90's by organizations like IBM, Ericsson or the US Army with up to 20x gains in quality and 4.6x gains in productivity. It can be used for current technology projects, but it needs the help of tools like Django for implementing it in an organization. In this workshop we will learn about this method and then we will do a practical exercise, first with basic tools and then using Django. PUBLIC CONFIRMED Workshop https://pretalx.evolutio.pt//2021/talk/SXFXBF/ Secondary Room Francisco J. López-Lira Hinojo PUBLISH 39Z3PC@@pretalx.evolutio.pt -39Z3PC From Development to Production, Getting Actionable Insights to Optimize Django Code Performance en en 20210604T143000 20210604T150500 0.03500

From Development to Production, Getting Actionable Insights to Optimize Django Code Performance

We’ll see how developers can see in real-time how end-user perceive the performance of an application, and the several levels through which Blackfire can drill down in order to find the root cause of issues. We’ll see how Blackfire can be used within CI/CD or any testing pipeline, to prevent issues from being released to production. And we’ll see how Blackfire can be used on a development machine to reproduce and analyze issues, as well as validate code iterations. Sponsored by: Blackfire.io PUBLIC CONFIRMED Other https://pretalx.evolutio.pt//2021/talk/39Z3PC/ Secondary Room Jérôme Vieilledent PUBLISH UUZQFJ@@pretalx.evolutio.pt -UUZQFJ What about DjangoCon Europe 2022? en en 20210604T164500 20210604T171500 0.03000

What about DjangoCon Europe 2022?

PUBLIC CONFIRMED Other https://pretalx.evolutio.pt//2021/talk/UUZQFJ/ Secondary Room David Vaz Miguel Magalhães