We Went To DjangoConAu! Here’s What We Learned

The team from Red Crow Digital recently attended DjangoConAu! Not only did we all learn a lot, we had great fun too. It’s no secret that we here at Red Crow Digital love Django, so we jumped at the chance to attend a whole day dedicated to it.

While writing an article on everything we learned and all the talks we attended would be far too long, there were some definite highlights. So if you want to see what it’s like being a Django developer or better understand what we do on a day to day basis, read on and find out.

Here are just a few of the talks we attended. But first, thank you so much to DjangoConAu for putting on this excellent conference. And thank you to the many wonderful speakers who gave us their time and knowledge. It was wonderful.

Multi-tenancy Strategies with Django and PostgreSQL

Speaker: Levi Cameron

Every project has its own purpose and aim. Because of this, each project also has its own requirements and considerations when it comes to managing data. Cameron’s multi-tenancy speech delved into several key strategies of database management, their pros and cons, and their considerations that are specific to Django.

Let’s take a look at the main strategies that Cameron suggested in his talk:

Shared Database with Separate Schemas

Sharing a common database with separate schemas allows each schema to be independent. This ensures that each scheme is secure and prevents data from being inaccurately shared between each schema. Through Middleware Mapping, schema routing is created to still give access to global ORM queries. While this is obviously a plus, having a shared database is not without its downsides, with the main downside being that if/when it comes to migration, your migration will be applicable to every schema.

To us here at Red Crow Digital, this is an interesting approach that would be great for larger companies that need separate but global querying. If that’s you, it’s definitely worth talking about when it comes to your data.

Shared Database with Row-Level Security

This is a great database strategy if you’re looking to reduce database overhead and eliminate the migration issues that come with multiple schemas. While each database row is protected by its own Tenants ID (which is a pro), the extra security means that all filters require that Tenants ID to be in place. However, Cameron shared a few work-arounds to this dilemma.

And thanks to the workarounds, we think this the most useful of the strategies that Cameron discussed. It’s not something that we considered before, but very much shows why it’s important to continue to educate yourself.

Designing Effective Load Test For Your Web Application

Speaker: Anthony Shaw

Load testing can ensure a website is prepared for high traffic. Prior to going live with a website, it’s important to understand your users in order to replicate a realistic load. Shaw discussed some useful tools and techniques to keep in mind that help developers design and perform effective load testing on a web application.

Key Load Testing Tools

• Locust: a Python library that can define virtual users through code and simulate up to millions of users making http requests.
• Playwright: a framework for automating web testing that can integrate with Locust. It can generate Python Locust files by recording browser sessions that can then be simulated by Locust.
• Mimesis: A data generator for Python that generates more realistic fake testing data.

Interpreting Results and Takeaways

When analysing the results you can expect certain patterns around warm up spikes, bottlenecks, and then a final stabilisation. It’s also important to take into account caching, as it may give an illusion of false performance, so introducing an element of randomness to testing may be advised.

Overall this was a great talk to attend. It’s always important to try to run a web application as efficiently as possible, and understanding what to expect in terms of load gave us some ideas for the future.

How to Pick the Right Third-Party Packages for Your Project

Speaker: Evan Brumley

With the abundance of third-party packages available to use in a project, it isn’t always clear which package to choose. There needs to be consideration put into whether the package is a “right fit” for a project for several reasons including security, long term support, and licensing. This talk was great to attend in order to keep the team up to date with new third-party packages and help us determine the right package to select.

Things to Consider When Selecting A Third Party Package

It’s important not to just pick a third-party package because it looks good. Instead, take the project architecture into account and consider:

• Do I really need this package?
• Will I use it correctly or as intended?
• How will it affect my existing codebase?

It’s also important to consider whether the package can be removed in the future if there is a maintenance or licensing issue. Of course no one has to remove a package, so it should also be ensured that the package is able to grow with the project and is well supported.

Assess Common Risks That Occur With Third-Party Packages

Third-party packages always come with a degree of risk, so it’s important to know these risks exist and how to handle them. Some risks include:

• Licensing risks: can the package be used legally with the project?
• Security risks: security is always a large concern, so it needs to be ensured that a package is updated regularly and has an active community.
• Maintenance risks: will this package be abandoned or does it have an active repository with regular commits?
• Quality risks: it needs to be ensured that the package has detailed release notes and documentation.

Overall, this talk was a great reminder to all developers who attended. Third-party packages are great tools for everyone, but it’s easy to become complacent when looking for a solution.

Final Thoughts on DjangoConAu

Again, it was great to attend DjangoConAu, and we thank all the wonderful speakers we got to see.

We only scraped the surface with some of the information we were able to learn while attending the conference, but hopefully you’ve either learned something from what we learned, or got a better understanding of the software development process and the considerations that developers make about client projects every day.

We also like to share this information with clients so that clients can understand how a larger project works. An educated client asks the right questions and gives the best feedback. If you have a project coming up, feel free to get in touch to discuss it.