0.8
2021
DjangoCon Europe 2021
2021-06-02
2021-06-06
5
00:05
https://pretalx.evolutio.pt/2021/schedule/
Europe/Paris
2021-06-02T09:15:00+02:00
09:15
00:45
Main Room
2021-155-programming-for-pleasure
https://pretalx.evolutio.pt//2021/talk/SPQP39/
false
Programming for pleasure
Talk
en
As programmers, we’re very lucky - our work is often creative and enjoyable, and the culture of programming itself is inventive and playful. Programming can be a pleasure in itself. What we don’t usually recognise is that the effect of this is to make the software we create worse rather better. If we want to make better software, we need to start programming not for pleasure, but for pain.
**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**.
Daniele Procida
2021-06-02T10:00:00+02:00
10:00
00:45
Main Room
2021-116-unlocking-the-full-potential-of-postgresql-indexes-in-django
https://pretalx.evolutio.pt//2021/talk/EYKPU8/
false
Unlocking the full potential of PostgreSQL indexes in Django
Talk
en
Developers who are not familiar with databases often fear them, and prefer to treat them like a blackbox. Indexes are extremely powerful and Django provides many ways of using indexes to make queries faster.
In this talk I’ll present advanced indexing technics in PostgreSQL using the Django ORM.
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!
Haki Benita
2021-06-02T10:45:00+02:00
10:45
00:45
Main Room
2021-112-your-very-own-real-time-chat-with-django-channels
https://pretalx.evolutio.pt//2021/talk/ECY3JD/
false
Your very own real time chat with Django Channels
Talk
en
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.
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
Amanda Savluchinske
2021-06-02T11:30:00+02:00
11:30
00:45
Main Room
2021-143-telepath-adding-the-missing-link-between-django-and-rich-client-apps
https://pretalx.evolutio.pt//2021/talk/DMYMEE/
false
Telepath - adding the missing link between Django and rich client apps
Talk
en
Introducing a new approach to sharing data models between Python and JavaScript, to help in building Django apps with rich client-side functionality.
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.
/media/2021/images/DMYMEE/telepath-800x600_zz7CXbG.jpg
Matt Westcott
2021-06-02T12:15:00+02:00
12:15
00:45
Main Room
2021-125--a-sql-for-django
https://pretalx.evolutio.pt//2021/talk/PC7PZP/
false
(A) SQL for Django
Talk
en
Django's ORM is full-featured, simple to use, and well-suited for almost all interactions with your database. But sometimes, to get better performance or to get data in just the format that you need, it is useful to have the full expressiveness of SQL in your Django application.
In this talk, we will look at using SQL with Django. We will see in which situations the use of SQL makes most sense. You will see the power of SQL and the best ways to use SQL with Django.
We will start with a short review of SQL and of use cases for which SQL gives you more fine-grained control and better results than Djangos ORM. Then, we look at raw SQL queries and RawQuerySets. RawQuerySets make it possible to get model instances with custom SQL. Finally, we learn how to directly work with Django SQL connections and use SQL change your data or get results that don't fit any particular model instance.
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
Stefan Baerisch
2021-06-02T13:50:00+02:00
13:50
01:15
Main Room
2021-175-keynote-how-to-be-a-djangonaut-in-a-climate-emergency
https://pretalx.evolutio.pt//2021/talk/TZ8E7H/
false
KEYNOTE | How to be a djangonaut in a climate emergency
Keynote
en
The science on climate spells out the need for rapid, far-reaching, and unprecedented changes to how we work and live. What does this mean for the way we build digital services as djangonaugs?
We’ll explore what we can, and should be doing as professional technologists in a climate emergency, the patterns emerging for more sustainable software engineering, and what a django designed to be the best choice for building future climate tech services might look like.
Chris Adams
2021-06-02T15:05:00+02:00
15:05
00:45
Main Room
2021-139-full-stack-django-rest-framework
https://pretalx.evolutio.pt//2021/talk/NBUHRU/
false
Full-stack Django Rest Framework
Talk
en
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
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)
/media/2021/images/NBUHRU/bekir-donmez-eofm5R5f9Kw-unsplash_AkFKxJk.jpg
Thiago Garcia da SilvaIsrael da Silva Teixeira
2021-06-02T15:50:00+02:00
15:50
00:45
Main Room
2021-128-writing-safe-database-migrations
https://pretalx.evolutio.pt//2021/talk/F9J8CU/
false
Writing Safe Database Migrations
Talk
en
Whether you build Django projects or apps, you won’t get past database migrations. Let me show you some pitfalls, potential problems, and how to write safe ones.
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).
Markus Holtermann
2021-06-02T16:35:00+02:00
16:35
00:45
Main Room
2021-150-hunting-performance-in-django-code
https://pretalx.evolutio.pt//2021/talk/PLFDVE/
false
Hunting Performance in Django Code
Talk
en
This talk aims to explain the core concepts/use cases of various profilers in Python/Django world. I will walk over the different types of profilers and the basic use cases for them. The variance in Python Profiling tools we have today can actually be very useful if you know how and when to use them.
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
Sümer Cip
2021-06-02T17:20:00+02:00
17:20
00:45
Main Room
2021-132-domain-driven-design-with-django-and-graphql
https://pretalx.evolutio.pt//2021/talk/JM9UY7/
false
Domain Driven Design with Django and GraphQL
Talk
en
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.
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.
Patrick Arminio
2021-06-02T09:45:00+02:00
09:45
00:50
Secondary Room
2021-157-getting-started-with-react-graphql-and-django
https://pretalx.evolutio.pt//2021/talk/LMWU8L/
false
Getting started with React, GraphQL, and Django
Workshop
en
What is GraphQL? When would I use it instead of DRF? How does it work with my models? In this session, we'll answer all these questions and more as we walk through a working example of a React, GraphQL, and Django application.
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.
Aaron Bassett
2021-06-02T12:00:00+02:00
12:00
00:50
Secondary Room
2021-115-teaching-cpython-turtle-graphics-and-jinja2-in-the-browser
https://pretalx.evolutio.pt//2021/talk/YXVTVE/
false
Teaching cPython, Turtle Graphics, and Jinja2 in the Browser
Workshop
en
By the end of this class you will have the tools to teach Python, Jinja2 and web development to a class of remote students.
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.
/media/2021/images/YXVTVE/ForestWiki_ewgB9a9.png
Christopher Lozinski
2021-06-02T15:30:00+02:00
15:30
00:50
Secondary Room
2021-117-django-sketchnoting-challenge
https://pretalx.evolutio.pt//2021/talk/UQVXM9/
false
Django Sketchnoting Challenge
Workshop
en
Sketchnoting is the process of taking visual notes by combining symbolic illustrations and text. In this workshop we will learn the basics of sketchnoting first. And then we will make visual notes about Django concepts! Grab a pencil and some paper, and let's sketch!
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.
/media/2021/images/UQVXM9/request_response_MgWE8Wa.png
Sara Peeters
2021-06-03T09:15:00+02:00
09:15
00:45
Main Room
2021-144-dynamic-static-sites-with-django-and-sphinx
https://pretalx.evolutio.pt//2021/talk/YY3LBL/
false
Dynamic static sites with Django and Sphinx
Talk
en
You're building a content site? Can't face a CMS? Well have the best of all worlds!
Write your site content in Markdown. Manage it on the file system with git.
Use all the power of Sphinx to build your site, but server it with Django.
Cross-referencing, content super-powers meet auth, forms, interactivity,
dynamic content and all the rest of it. .
You don't have to choose, and you don't have to roll your own either.
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.
Carlton Gibson
2021-06-03T10:00:00+02:00
10:00
00:45
Main Room
2021-161-anvil-full-stack-web-with-nothing-but-python
https://pretalx.evolutio.pt//2021/talk/KXQPUU/
false
Anvil: Full Stack Web with Nothing but Python
Talk
en
What if we could build our front ends in Python too? Anvil is a framework to get us there: no HTML, JS, CSS, React, Bootstrap or Webpack required!
Instead, how about a Python UI toolkit, a drag-and-drop designer, and a full-stack runtime that doesn't require you to squeeze all your application state over JSON and HTTP? Find out how it's done, and why I think it's a good idea.
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!
Meredydd Luff
2021-06-03T10:45:00+02:00
10:45
00:45
Main Room
2021-114-hacking-django-channels-for-fun-and-profit-
https://pretalx.evolutio.pt//2021/talk/VYNPNR/
false
Hacking Django Channels for Fun (and Profit)
Talk
en
Django is growing some great async features and Channels has been great for handling websockets connecting from your visitor's browser. But what happens when you need to do more? What if you want to keep long-running connections from Django to other websockets, such as Discord servers? How do you do this and still leverage all the batteries included with Django? We will show an approach that makes this all possible and easy as a developer.
- 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%
Calvin Hendryx-Parker
2021-06-03T11:30:00+02:00
11:30
00:45
Main Room
2021-141-modern-javascript-for-django-developers
https://pretalx.evolutio.pt//2021/talk/F7EZXH/
false
Modern JavaScript for Django Developers
Talk
en
Many Django developers are intimidated by "modern" JavaScript, and those that aren't tend to throw away much of Django and use it only as an API for a standalone JavaScript front end.
This talk will outline the options for using Django with a modern framework like React or Vue, and deep dive on everything you'd need to know to incorporate modern JavaScript into a Django project without giving up Django's View/Template system.
It will also highlight some of what you gain by embracing modern JavaScript.
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.
Cory Zue
2021-06-03T12:15:00+02:00
12:15
00:45
Main Room
2021-126-clean-architecture-with-django-rethinking-basic-assumptions
https://pretalx.evolutio.pt//2021/talk/NCTBUS/
false
Clean Architecture with Django: Rethinking basic assumptions
Talk
en
There are two main problems in implementing the Clean Architecture (CA) pattern with Django projects: developers are often not clear on what a Clean Architecture would look like with Django and secondly the framework itself resists adaption to the CA paradigm.
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).
Paul Wolf
2021-06-03T13:50:00+02:00
13:50
01:15
Main Room
2021-173-keynote-spreading-our-tentacles-taking-a-django-app-global
https://pretalx.evolutio.pt//2021/talk/VCTVRB/
false
KEYNOTE | Spreading our tentacles - taking a Django app global
Keynote
en
Imagine you built a pretty snazzy Django app to transform your company's business. You're helping with revolutionising the energy industry to make better use of green energy. Pretty cool right? Now imagine your company is expanding to new countries and not only that, other companies want to use your app too. Even better! But also imagine you wrote that app specifcally with your company in one country in mind. This talk is going to cover the approach we've taken in transforming our app to work for multiple clients in multiple countries while still keeping the core of it the same.
Frederike Jaeger
2021-06-03T15:05:00+02:00
15:05
00:45
Main Room
2021-138-htmx-frontend-revolution
https://pretalx.evolutio.pt//2021/talk/PZ3KWB/
false
HTMX: Frontend Revolution
Talk
en
HTMX is a tiny JavaScript library which helps you to avoid JavaScript. Instead of sending JSON over the wire (like React, Vue, ...) it sends HTML fragments over the wire.
It simplifies the toolchain and the result are fast pages with good SEO (web vitals) scores.
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
Thomas Güttler
2021-06-03T15:50:00+02:00
15:50
00:45
Main Room
2021-168-you-might-not-need-a-frontend-framework
https://pretalx.evolutio.pt//2021/talk/RE7AVL/
false
You might not need a frontend framework
Talk
en
Javascript is eating the world, but it does not need to eat your project too!. In this talk we will explore lightweight frontend solutions for progressively enhancing a Django web page.
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.
/media/2021/images/RE7AVL/13mw_cLW0hVCgtlTQsw_f6g_93zlKbT.jpeg
Afonso Cerejeira
2021-06-03T16:35:00+02:00
16:35
00:45
Main Room
2021-158-django-with-postgresql-superpowers
https://pretalx.evolutio.pt//2021/talk/DXMJ8H/
false
Django with PostgreSQL superpowers
Talk
en
**Django** per se is a _database-agnostic_ web framework, but _real-world projects_ based on it are not. **PostgreSQL** has the _richest feature set_ of any supported databases and we'll see how to use these **superpowers** in _Django_.
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/**
/media/2021/images/DXMJ8H/nam-anh-QJbyG6O0ick-unsplash_3Y40kSN.jpg
Paolo Melchiorre
2021-06-03T17:20:00+02:00
17:20
00:45
Main Room
2021-134-how-to-create-a-full-stack-reactive-website-in-django-with-absolutely-no-javascript
https://pretalx.evolutio.pt//2021/talk/FJLKVT/
false
How to create a full-stack, reactive website in Django with absolutely no JavaScript
Talk
en
Utilize Django to build modern, interactive websites without needing a complicated frontend framework.
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.
Adam Hill
2021-06-03T09:45:00+02:00
09:45
00:50
Secondary Room
2021-179-profiling-django-python-apps
https://pretalx.evolutio.pt//2021/talk/VJD9VP/
false
Profiling Django & Python apps
Workshop
en
It is difficult to improve what is not measurable! Profiling an application should always be the first step in trying to improve its performance. With this workshop, learn how to identify performance issues in your application and adopt the best profiling practices in your daily development habits. This workshop will use the Blackfire.io tool to help you identify performance leaks.
Sponsored by Blackfire.io
Jérôme VieilledentSümer Cip
2021-06-03T12:00:00+02:00
12:00
00:50
Secondary Room
2021-146-django-unstuck-suggestions-for-common-challenges-in-your-projects
https://pretalx.evolutio.pt//2021/talk/RW9FVH/
false
Django Unstuck: Suggestions for common challenges in your projects
Workshop
en
There are some challenges that come up in every Django project. Some of them right at the start: How do I organize my apps? Where do I put the base template, and all the other templates? Should I do internationalization right away?
Other problems only crop up a little later: how do I manage production settings? How do I make sure permissions are checked correctly? How do I make menus appear correctly?
Some may appear at any point in time: how do I add content pages? What code goes into models/controllers/views?
In this workshop, I'm going to tell you how I approach these recurring challenges and what my "best practices" in these situations are.
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/**
Johannes Spielmann
2021-06-03T15:30:00+02:00
15:30
00:50
Secondary Room
2021-169-managing-multiple-django-services-in-a-single-repo
https://pretalx.evolutio.pt//2021/talk/CTXYZE/
false
Managing multiple Django services in a single repo
Workshop
en
Django projects are standalone by nature, but with the right tooling and practices you can effectively maintain many interrelated Django services in a single streamlined repo, with minimal boilerplate and copypasta.
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!
Benjy Weinberger
2021-06-03T17:00:00+02:00
17:00
00:30
Secondary Room
2021-113-deploying-a-django-virtual-event-platform-using-containers-and-terraform
https://pretalx.evolutio.pt//2021/talk/UBAQPR/
false
Deploying a Django Virtual Event Platform Using Containers and Terraform
Other
en
Learn to leverage cloud native tools and launch a scalable Python and Django application into the Cloud with Fargate. We’ll dive in with how to getting up and running fast, but leaving the overhead of managing virtual machines and Kubernetes behind. Create and store the application Docker images in a container repository and without touching the AWS console we can create fully Infrastructure as Code automated deployments via CodePipeline into Fargate containers and S3 buckets. Deliver the React application via CloudFront and S3 for full global scalability. Leave the legacy deployments behind and forge bravely into the new world of Cloud Native applications.
- 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
Calvin Hendryx-Parker
2021-06-04T09:15:00+02:00
09:15
00:45
Main Room
2021-153-speed-up-your-tests-with-setuptestdata
https://pretalx.evolutio.pt//2021/talk/NS9S7N/
false
Speed up your tests with setUpTestData
Talk
en
TestCase.setUpTestData allows you to create test data once per TestCase, rather than once per test. This talk will cover how it works, how it improved in Django 3.2, and how to convert your tests to use it.
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.
Adam Johnson
2021-06-04T10:00:00+02:00
10:00
00:45
Main Room
2021-119-rewriting-django-from-almost-scratch-in-2021
https://pretalx.evolutio.pt//2021/talk/QQJ9WB/
false
Rewriting Django from (almost) scratch in 2021
Talk
en
You're probably asking yourself "Why would someone wanna do that?". Django is one of the most successful web frameworks out there, the codebase is well established and well tested.
That is true. On the other hand, a codebase that old is bond to have some technical debt.
IMHO, Django's technical debt is mostly situated in the admin which is one of the most appreciated features of Django while at the same time, possessing the least people familiar with its internals or willing to learn them.
Another sort of technical debt is one that is backward compatibility and having to keep choices made more than a decade ago.
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
/media/2021/images/QQJ9WB/cordy-lg_lNk3ZYG.png
Emma Delescolle
2021-06-04T10:45:00+02:00
10:45
00:45
Main Room
2021-120-get-interactive-putting-a-shell-or-a-desktop-in-your-django-app
https://pretalx.evolutio.pt//2021/talk/LKQSE7/
false
Get interactive! Putting a shell (or a desktop) in your Django app
Talk
en
How to make your Django app speak SSH or RDP with Guacamole, ASGI and Daphne — giving anyone a console or a desktop right in their browser!
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/>.
Florian HaasMaari Tamm
2021-06-04T11:30:00+02:00
11:30
00:45
Main Room
2021-121-build-deploy-and-scale-django-graphql-and-spa
https://pretalx.evolutio.pt//2021/talk/GWVRVA/
false
Build, deploy and scale: Django, GraphQL and SPA
Talk
en
How to build GraphQL APIs with Django that can serve millions of requests per second? Strategies to deploy your API and SPA for production and non-production workloads.
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).
/media/2021/images/GWVRVA/poster_Gsf0398.png
dhilipsiva
2021-06-04T12:15:00+02:00
12:15
00:45
Main Room
2021-164-load-testing-a-django-application-using-locustio
https://pretalx.evolutio.pt//2021/talk/TXENJP/
false
Load Testing a Django Application using LocustIO
Talk
en
Load testing is critical in the software development lifecycle as it evaluates application performance affected by normal and peak loads by simulating access and usage by multiple users concurrently.
LocustIO, an open source tool written in python, is used for load testing of web applications. It is simple and easy to use with web UI to view the test results. Let's make load testing quick and easy with 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.
/media/2021/images/TXENJP/Screenshot_2021-04-02_at_12.49.55_AM_A0E1IZK.png
Pranjal JainVibhash Chandra
2021-06-04T13:50:00+02:00
13:50
01:15
Main Room
2021-174-keynote-we-re-all-part-of-this-jazzband-5-years-later
https://pretalx.evolutio.pt//2021/talk/SDMA7T/
false
KEYNOTE | We're all part of this: Jazzband 5 years later
Keynote
en
The Jazzband project was launched 5 years ago to help maintainers find a way to secure the long-term maintenance of their Python projects. The result was a collective of volunteers that stepped up in a big way on the way to solve Open Source sustainability.
In this talk I'll dive into the history of the project, the good and bad of running the project for >5 years and the next steps for Jazzband.
/media/2021/images/SDMA7T/jazzband_copy_22x_fyEUOE8.png
Jannis Leidel (he/him)
2021-06-04T15:05:00+02:00
15:05
00:45
Main Room
2021-154-the-request-response-cycle-a-djangonautic-journey
https://pretalx.evolutio.pt//2021/talk/7B9YYD/
false
The request/response cycle - a Djangonautic journey
Talk
en
A Django-layer-focused look at the classic interview question: "what happens when you click a link?". From the initial call to the request handler, through to what it finally returns; a deep dive into Django's handlers and middleware.
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.
Timothy McCurrach
2021-06-04T15:50:00+02:00
15:50
00:45
Main Room
2021-147-all-about-the-django-software-foundation-dsf-
https://pretalx.evolutio.pt//2021/talk/APN93S/
false
All about The Django Software Foundation (DSF)
Talk
en
The Django Software Foundation (DSF) is the independent foundation established as a 501(c)(3) non-profit that supports the development of Django. The goal of the DSF is to promote, support, and advance its open-source project, the Django Web framework. In my talk, I will give an overview of what the DSF is doing to support the advancement of Django through the various teams, committees, and boards that make up the foundation. I will also talk about how to contribute to the advancement of Django through both code and non-code contributions.
DSF SLOT
Anna Makarudze
2021-06-04T16:35:00+02:00
16:35
00:45
Main Room
2021-160-serving-files-with-django
https://pretalx.evolutio.pt//2021/talk/E8AYPU/
false
Serving Files with Django
Talk
en
Is it possible to use just Django to serve static/media files? Even thousands of clients in parallel while saturating at least a 1Gbit link? I believe it is :) (now).
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 :).
Jochen Wersdörfer
2021-06-04T17:20:00+02:00
17:20
00:45
Main Room
2021-170-securing-django-applications
https://pretalx.evolutio.pt//2021/talk/NUKNRB/
false
Securing Django Applications
Talk
en
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.
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)
Gajendra Deshpande
2021-06-04T09:45:00+02:00
09:45
00:50
Secondary Room
2021-136-migrations-and-understanding-django-s-relationship-with-its-database
https://pretalx.evolutio.pt//2021/talk/VHFEDF/
false
Migrations and understanding Django's relationship with its database
Workshop
en
Do _IntegrityError: NOT NULL constraint failed_, _column cannot be null_ or _OperationalError: no such column_ ring a bell? Most Django developers experience those either during development, or worse, in production. We'll explore the whys and wherefores of these problems and suggest some solutions in order to improve your experience with Django migrations and make them seamless.
Slides: https://drive.google.com/file/d/13wsg1yYWX0aJrLuA4a-GRnej42GBN1CK/view?usp=sharing
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
David Wobrock
2021-06-04T12:00:00+02:00
12:00
00:50
Secondary Room
2021-130-cleanroom-software-engineering-with-django
https://pretalx.evolutio.pt//2021/talk/SXFXBF/
false
Cleanroom Software Engineering with Django
Workshop
en
Cleanroom software engineering process is a software development process developed at IBM intended to produce software with a certifiable level of reliability. A principal objective of the Cleanroom process is development of software that exhibits zero failures in use. In this workshop we will review how to implement it in a project with the help of 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.
/media/2021/images/SXFXBF/Copy_of_event_flyer_-_Made_with_PosterMyWall_pjMiam1.jpg
Francisco J. López-Lira Hinojo
2021-06-04T14:30:00+02:00
14:30
00:35
Secondary Room
2021-181-from-development-to-production-getting-actionable-insights-to-optimize-django-code-performance
https://pretalx.evolutio.pt//2021/talk/39Z3PC/
false
From Development to Production, Getting Actionable Insights to Optimize Django Code Performance
Other
en
Blackfire offers a unique blend of Monitoring and Profiling features. Unlike traditional APMs on the market, it focuses on the quality of the data it collects, rather than its quantity, in order to make sure developers know quickly what they can do to fix issues.
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
Jérôme Vieilledent
2021-06-04T16:45:00+02:00
16:45
00:30
Secondary Room
2021-178-what-about-djangocon-europe-2022-
https://pretalx.evolutio.pt//2021/talk/UUZQFJ/
false
What about DjangoCon Europe 2022?
Other
en
We hosted the last two DjangoCon Europe 2020 and 2021. What about 2022? Who is next?
We will share our experience over the last two years, the good the bad and the ugly.
DjangoCon Europe will go on and following the tradition we will pass over the olympic torch to whoever wants to continue.
The first step is to apply with DSF, but during the submission you will already need to have a general Idea of the overall organization.
David VazMiguel Magalhães