A relatively up to date list of technical talks our staff has given at various conferences, user group meetups, and other venues.
A relatively up to date list of technical talks our staff has given at various conferences, user group meetups, and other venues.
Frank talked about Django's early history. A few great stories from the very early days of Django and how we managed to get it Open Sourced.
Frank Wiles was on the closing panel discussion about developer career paths beyond coding at DjangoCon 2023 in Durham, NC
Jeff Triplett was on this year's State of Django panel at DjangoCon US: 2022 which covered: the state of the Django codebase and also the state of the Django community as represented by organizations like the Django Software Foundation, Django Girls, the Python Software Foundation and DEFNA.
I'll be proposing a new category of code contributor I'm calling "Code Contributor Mentor", and also enumerating the need to recognize, recruit & support non-code contributors. As a largely volunteer-driven community, the Django code base and community rely on their contributors. In this talk I'll focus on two different categories of contributors the Django community needs: - Code Contributors - Non-Code Contributors The first part of the talk will propose a new category of code contributor: Code Contributor Mentors. These contributors are meant to provide an intermediate layer of support. They would benefit both current project maintainers (who are often overworked volunteers) and potential new contributors (who are often overwhelmed with how/where to start or continue). The second part of the talk will focus on the often-overlooked need for non-code contributors. Django (as well as Python and other related projects) are large enough that they need contributions beyond code. These contributions range from needs on the global level, on the DSF & PSF boards, to local meetups & conferences. But these needs are often overlooked since they're not code-related. The goal of the talk is to both raise awareness of issues, but also propose potential solutions.
Kojo Idrissa was an accountant who got an MBA and taught at university in two different countries. He's now a parent, software engineer, intercontinental keynote speaker, DjangoCon US organizer and the DEFNA North American Ambassador #NorAmGT. He's spoken at tech conferences about software engineering practices, spreadsheets, contributing to tech communities, Dungeons & Dragons, inclusion, and privilege. He’s made a few small FLOSS contributions to CPython & Jinja, as well as Drupal (a LONG time ago). He’s also made contributions to Codecombat, where he helped others make their first OSS contributions, and PyVideo, where he updated the Tags section of the Contribution guide for their Data repo.
When I started writing Django REST Framework code in 2017, there was a lot I didn't know, like how class-based views worked and what a serializer was. After 3+ years of using DRF, I want to share the things I've learned that make writing DRF code easier and faster for me. You will learn how to save time and lines of code by using DRF's built-in viewsets (and what a viewset is), when to skip the viewset and use a built-in generic APIView, and how to add custom endpoints (actions) to your viewsets. You'll also learn how modular DRF can be when you customize built-in methods or use different serializers for different parts of your viewset, and how tools like Classy DRF can help.
There's one part of building a Django app I hate: setting up handling of assets and media. There are so many moving pieces — static assets, asset compilation and compression, file uploads, storage engines, etc. etc. I can never remember how it all fits together. I wrote this talk for one very selfish reason: to document how this all works, in one place, once and for all. This talk is primarily intended for Django developers who want to build an asset pipeline that Just Works. The bulk of the talk covers front-end tooling (Webpack, PostCSS, Babel, etc.), so full-stack developers of any stripe will find something here, too.
Join us for a panel on the State of Django: the state of the Django codebase, but also the state of the Django community as represented by organizations like the Django Software Foundation, Django Girls, and DEFNA. Panelists include Frank and Jeff.
In this talk, you will step through the parts of a Dockerfile and learn what they do. Then, Lacey will introduce you to Docker Compose and explain why using it to run multiple containers is helpful. Finally, you will learn to run commands and execute scripts from the command line using Docker, how to enter a container and why you might need to, and what to do before you go home for the day.
As a developer with two English degrees, over the years Lacey has identified some concrete ways this education makes me a better developer. This talk will discuss how we can take lessons from literature to write more readable code, make better tests, and create more usable websites. At the end of the day, after all, our job is to write. Surely the techniques of great writers have something to teach us.
Wagtail is a great Django CMS, but getting started with it is a little intimidating. Wagtail has a ton of useful features that their docs don’t go into, so this talk is here to help! You’ll get to know the Page class, add redirects, make your Page relationships healthier, and handle users easily.
In this talk, you will step through the parts of a Dockerfile and learn what they do. Then, Lacey will introduce you to Docker Compose and explain why using it to run multiple containers is helpful. Finally, you will learn to run commands and execute scripts from the command line using Docker, how to enter a container and why you might need to, and what to do before you go home for the day.
This talk slot was originally for Josh Berkus, but he injured his back the week prior to the conference so Frank stepped in with a pretty similar talk on the same topic, Kubernetes. The hardest thing about Kubernetes is getting a handle on the jargon. Frank walks you through all of the various bits to help you run a Django web application on k8s.
In this group of people, there is one thing we most certainly have in common: We're all bug hunters. Whether you've spent your last sabbatical in Borneo studying the embeddable iPython or you've only just begun your career and wonder at anyone using more than django-debug-toolbar, we can all learn from the latest trends and research in bug hunting. From Frank's his early childhood of having a simple ant farm, up to and including his long experience in the deepest, most pristine, and undisturbed wilds of the Internet, his experience has honed his abilities to find and identify bugs. Learn some of the best tools of the trade that will help in your daily hunts. Bug hunting tech you will learn about: - django-debug-toolbar - pdb/ipdb - using iPython embed - effectively using Python logging so you don't need to use the last quite so often Bug hunting is all about visibility. You may have the best net ever invented, but you can't catch a bug you can't see. Sure, you can spend all day turning over rocks and hope for the best or you can gear up with the tried and true night vision goggles all the pros use.
In this talk, I'll review what has been written in the last few decades on nomenclature, go over the easy parts of right or wrong as defined in PEP8 and other style guidelines, and finally suggest some patterns and anti-patterns found in today's Django and open source environment for us to adopt (or avoid!) in our everyday naming of variables, libraries and other "things".
Collecting and visualizing metrics is hard right, so we'll do them later. Learn how to easily collect any server or client side metrics with Django, InfluxDB, and Graphana.
Advice for raising healthy happy systems and getting to DevOps Nirvana. Observations of what works and doesn't work when doing devops. Suggested tools and processes and how to get what you want out of management.
There are tons of great little features, libraries, and useful tips out there. Python is a relatively easy language to learn, but the whole ecosystem is vast and it's really easy to not know all the cool tips and tricks. Frank gives you a few of the best ones that can vastly speed up your day to day development.
A panel at DjangoCon 2014 with, Andrew Godwin, Frank Wiles, Honza Král, and Peter Baumgartner. Have questions about getting better performance out of Django or scaling it up large? We've assembled a group of knowledgeable Django experts who have been there to answer the questions you have. While every site has its own challenges most follow similar patterns that are often easy to solve.
Jacob Burch and Jacob Kaplan-Moss teamed up to discuss how to remove or replace aspects of Django that you don't like. Which are easy to do and which are harder. Topics include replacing Django templates with jinja2, replacing the ORM, etc. Given at the very beautiful venue Île des Embiez - France for DjangoCon EU 2014.
Frank discusses Django performance aspects that are easy to miss, but also easy to fix. Most without a single line of code changes to your project and can yield noticeable performance improvements to your Django applications.
Jacob Burch's wildly popular talk on contributing to Django. Breaking all the rules on talks he goes from idea, to code, to contribution while haggling with core contributors in the audience live! Highly recommended.
Coming from a speaker who escaped a notion to "why would we need to translate?" this talk aims to show what actually goes into translating a website or app using Django's Internationalization tools. Covered will be an overview of batteries included, best practices and anti-patterns in using them, and some third party tools to help make your life escaping the myth of a Lingua Franca easier.
Frank will take us through a quick tour of the must have tools for the modern Django developer: South, Django Debug Toolbar, Celery, Fabric, Haystack, Tastypie, IPython, and so on. This talk from March 2012 at BostonPython was a "Django Developer's Survival Guide" that covered essential tools and libraries for Django developers. Frank Wiles from Revolution Systems presented a comprehensive overview of key development tools including IPython for enhanced interactive Python shells and debugging (with tips on using embed() and ipdb.set_trace()), the Django Debug Toolbar for inspecting SQL queries and request data, South for handling database schema and data migrations, Celery for asynchronous task processing, Haystack for search functionality across multiple search engines, django-tastypie for creating REST APIs, and Fabric for deployment automation and server management. The presentation was clearly aimed at helping Django developers become more productive by introducing them to the most important third-party tools in the Django ecosystem at that time, with practical code examples showing how to implement each tool.
Jacob Burch also gave this popular talk again at PyCon 2012 in Santa Clara.
PostgreSQL is pretty powerful all on its own, but did you know you can use Python as a stored procedure language? Not only does using a familiar language make development easier, but you get the power of the standard library and PyPi to boot. Come learn the ins and outs of putting Python in your DB. This conference talk from March 2012 presents "Putting Python in PostgreSQL" by Frank Wiles, exploring how to use PostgreSQL's PL/Python extension to write database functions and triggers in Python instead of PL/pgSQL. The presentation covers the installation and setup process, demonstrates basic Python functions within PostgreSQL, explains datatype mappings between PostgreSQL and Python, and showcases practical applications including database triggers for data validation, Redis integration for real-time counters, and credit card validation. While Wiles acknowledges the performance overhead and debugging challenges inherent in this approach, he positions PL/Python as a valuable tool for specific use cases such as data aggregation, constraint enforcement across development teams, retrofitting features into existing systems without modifying application code, and leveraging Python's extensive library ecosystem for tasks like external API calls, email notifications, and cache management directly within the database layer.
An open Q&A discussion we did with Alex Gaynor at Boston Python.
This talk aims to briefly introduce the core concepts of caching and covers the best practices of using Django's cache backend. "Are you caching?" is a question asked early on in any yarn on web scaling advice. These conversations are much better steered by asking a more open and difficult questions "What is your caching strategy?" and “How are you implementing it?” This talk aims to briefly introduce the core concepts of caching and quickly moves to cover the best practices of using Django’s cache backend. We will let the audience know what the important questions to ask are, give them advice on how to implement the right answers, and when even the built-in core backend isn’t enough, point them to more advanced techniques and the right third party tools.
PostgreSQL is effectively the default RDBMS for Django. Learn the dark arts of optimizing this powerful database to be blazingly fast on your own hardware or in the cloud. This conference talk from 2011 by Frank Wiles of REVSYS presents a comprehensive guide to PostgreSQL performance optimization, emphasizing practical techniques for improving database speed and efficiency. The presentation covers fundamental principles like measuring performance before and after changes, aggressive caching strategies, and monitoring query counts, while also diving into specific tuning parameters such as shared_buffers, effective_cache_size, and work_mem. Wiles addresses hardware considerations including the importance of RAM, disk configuration (favoring RAID-1+0 over RAID-5), and the benefits of separating WAL files onto dedicated storage, while also covering Django-specific optimization techniques like proper use of select_related(), avoiding queries in loops, and implementing proper indexing strategies. The talk concludes with advanced "dark arts" techniques including table partitioning, materialized views, and custom replication solutions, making it a thorough resource for developers and database administrators looking to maximize PostgreSQL performance in web applications.
Panel discussion on ways to sell Python to people who are adverse to the idea.
A panel to discuss the future of no-sql/non-related databases in Django.
While pre-optimization is often the root of all evil, knowing how to think about performance and scalability are important skills for any geek. Learn about all the knobs you didn't know you could or should tweak. Code profiling and dealing with your database aren't the only places to find performance gains. Performance and scalability are holistic endeavors.
So you’ve written a Django site… now what? Writing the application is just the beginning; now you’ve got to put it into production! In this hands-on workshop we’ll walk through the creation of a full Django deployment environment running on a cluster of (virtual) machines.
This is Frank Wiles' introductory conference talk about Django from February 2010, presenting Django as a BSD-licensed Python web framework designed for "perfectionists with deadlines." The presentation covers Django's core Model-View-Template architecture, explaining how models handle database interactions and business logic, views (controllers) process URL routing and application logic, and templates manage presentation using Django's template language. Wiles demonstrates Django's capabilities through code examples of a simple blog application, showcases the powerful auto-generated admin interface, and highlights advanced features like GeoDjango for geographic applications, generic views for rapid development, and the extensive ecosystem of reusable applications. The talk emphasizes Django's origins at the Lawrence Journal-World newspaper, its adoption by major organizations like NASA, Discovery Channel, and The Guardian, and positions it as suitable for everything from rapid prototyping to large-scale production deployments.
This September 2009 conference talk by Frank Wiles from Revolution Systems focused on PostgreSQL performance optimization with the core principle that "performance is about doing less, not doing something faster." The presentation covered essential postgresql.conf configuration settings including shared_buffers (10-20% of RAM), effective_cache_size (75% of RAM), and work_mem (sized for ORDER BY operations), before diving into materialized views as a powerful optimization technique. Wiles demonstrated how creating pre-computed tables could dramatically improve query performance - showing a real example where a complex voting query that took 4.2 seconds was reduced to 0.345 seconds using a materialized view, and then explained how to maintain these views in real-time using PostgreSQL triggers with pl/python functions, making this approach suitable for time-based aggregations, denormalizing frequent queries, and any scenario where SELECT operations significantly outnumber INSERT/UPDATE operations.
Django from the perspective of the Perl world. This 2009 conference talk by Frank Wiles from Revolution Systems uses addiction metaphors to humorously describe his transition from being a devoted Perl developer to embracing Django, the Python web framework. Wiles explains why he became "addicted" to Django, citing benefits like better code quality (measured humorously in "WTFs per minute"), easier project setup with tools like django-admin.py and zc.buildout, reduced hand strain from typing, better testing infrastructure, and faster development times. He acknowledges what Django was missing compared to Perl's ecosystem at the time, including a centralized package repository like CPAN, more comprehensive documentation and tutorials, a dedicated Q&A site like Perlmonks, centralized user groups, and shared community hosting infrastructure. The presentation concludes with his tongue-in-cheek advice on Django "addiction": "Just say YES!" - essentially recommending that developers should embrace Django despite being relatively new compared to Perl's mature ecosystem.
Web development sucks. It’s true: web development, at its worst, is difficult, repetitive, and boring. The tools we have suck. At best, they make web development slightly less painful, but we’re a long way from making web development awesome. The history of web development tools is a history of trying to solve this problem. It’s a history of asking, “how can we make this suck less?” It’s important to understand this history, because we can look at past trends and use them to predict the future.
This presentation by Frank Wiles from Revolution Systems covers the fundamental aspects of PostgreSQL database administration for beginners. The talk walks through essential tasks including initializing database clusters with initdb, creating databases and users, configuring access control through pg_hba.conf and SQL GRANT statements, optimizing performance through key configuration parameters like shared_buffers and effective_cache_size, implementing backup strategies using both pg_dump utilities and filesystem-level backups, and setting up warm standby replication using WAL archiving and recovery mechanisms. The presentation serves as a practical primer for database administrators new to PostgreSQL, focusing on core operational tasks rather than advanced features.
This presentation titled "Dolphins vs Elephants: A comparison of MySQL and PostgreSQL" by Revolution Systems provides a comprehensive technical comparison between the two popular open-source database systems. The talk covers key architectural differences, highlighting MySQL's multiple storage engines versus PostgreSQL's single unified approach, licensing and governance models, and their contrasting development philosophies - MySQL originally focusing on speed while PostgreSQL emphasized features and standards compliance. It examines data type capabilities, where PostgreSQL offers significantly richer built-in types including geographic, network, and custom composite types compared to MySQL's more basic offerings, as well as performance characteristics showing PostgreSQL's superior scalability under concurrent load and more extensive tuning options. The presentation includes compelling real-world case studies from FeedLounge and Yahoo, demonstrating PostgreSQL's efficiency gains and massive scalability potential, with Yahoo processing 24 billion events daily on a petabyte-scale system, ultimately positioning PostgreSQL as the more feature-rich, standards-compliant, and scalable solution for complex applications.
This February 2007 presentation by Frank Wiles introduces mod_perl 2.0 as a powerful Apache module that embeds a Perl interpreter directly into the web server, enabling dramatic performance improvements (up to 10x faster than traditional CGI), custom protocol implementations beyond HTTP, dynamic server configuration, and sophisticated request processing through Apache's lifecycle hooks. The presentation demonstrates practical applications including mass virtual host management from databases, content filtering for legacy applications, custom authentication and logging systems, and I/O filtering, while providing detailed code examples and configuration guidance that illustrate how mod_perl transforms Apache from a static web server into a programmable platform capable of handling complex server-side logic with substantially better performance than conventional CGI approaches.