Django structure for scale and longevity

Why? Django is great. But as we add new features, as our dev team grows and the software needs to be stable on production, things can get quite messy. We are going to look at some common patterns, derived from experience, on how to structure your Django project for scale and longevity. What? Main topics are: Django service layer or where should business logic live? Using Django Rest Framework in a clean and repeatable way and combining it with the service layer. Testing everything that matters, without repeating ourselves in different tests. We are going to talk about when to rely on existing abstraction so it's actually helpful and when to avoid existing abstraction, and code things ourselves. The examples showed in this talk are derived from working with Django in the last 5 years on projects with: Daily production usage and production deploys. Dozens of apps. Hundreds of models and APIs. Tens of integrations working simultaneously. Teams of 5 to 10 people. Who? Key takeaways from the talk: Increased productivity when developing with Django. Deeper understanding of the software development process with Django. Demo project with everything mentioned in it. The talk is great for all levels of Django knowledge - from beginners to advanced users and teams. How The main way of getting the point across is going to be by showing regular code, talking how it can get messy and then following up with examples of improving that code. Hopefully this talk will start a lot of discussion afterwards. Breakdown of the talk: Django service layer: Fat models or fat views? Where do I put my business logic? What is a service and what goes into a service? What is a selector and what goes into a selector? General Django structure: How many apps should I have? Structuring your code so youр team can be more productive and have less conflicts. Common modules and utilities. Doing APIs with Django Rest Framework: Splitting APIs in 2 groups - "giving data" and "taking data" Using a lot of generics for "give data" When do to selectors? Using no generics for "take data" (APIView + Services) Handling errors from services Inlining serializers and avoiding serializers reuse A neat inline_serializer util Introducing general error formatting for your API Testing all of that - what should be and not be tested?

Design Django Python Video

 The Pillars of Domain-Driven Design

Domain-Driven Design is neither a method nor a technology, it is a culture, a way of thinking about the needs of the customers first and putting an emphasis on their language and human interactions. The promise of DDD is to tackle complexity in the heart of software, and the means are plentiful and can be overwhelming. There are three pillars though, on which the whole approach stands. A focus on learning, language, and empathy. With the right mindset, it becomes simple to derive good models, keep them pure and aligned with the business. Simple is not easy, but done right Domain-Driven Design transforms everything in your organization from code to culture, from agile to architecture.

DDD Event Sourcing Video

 Stability Patterns & Antipatterns • Michael T. Nygard

Once you hit Release 1.0, your system will be living in the real world. It has to survive everything the messy, noisy real world can throw at it: from flash mobs to Twitter. Once the public starts [...]

Architecture Systems Video

 Unconditional Code • Michael Feathers

Many systems are full of error checks and conditional logic. They introduce discontinuities that make reasoning difficult. In this talk, Michael Feathers will present a conceptual framework for dealing with errors, conditionality and decision making at the level of code, architecture and user interface. Often by changing design and revisiting requirements we can make various error cases impossible, and make code and architecture simpler as well as more robust.

Abstraction Design Video

 Complex Adaptive Systems - Dave Snowden

Abstraction Philosophy Video

 Paradigms Without Progress: Kuhnian Reflections on Programming Practice

Borrowing from Thomas Kuhn, Robert Floyd introduced the notion of a programming paradigm. Today, paradigms are constantly debated. What might Kuhn tell us about this sad state of affairs? What can Programming learn from Philosophy?.

Paradigms Philosophy Video

 Greg Young - How to get productive in a project in 24h

So you are entering a new contract, or maybe it's just a new project you are being transferred to. How do you get up, going, and committing on your first day? How to identify the areas of the system that are risky or problematic? This session looks at tools and strategies to reach this goal coming from a speaker who regularly works for less than a week with a team and needs to provide value within that period of time

Code quality Observability Video

 Modeling Uncertainty • Vaughn Vernon

The foundation ideas behind Domain-Driven Design, or DDD, are fundamentally the same as when Eric Evans brought them to our attention through his seminal work. The Bounded Context with its Ubiquitous Language is still of chief importance, along with mapping various Bounded Contexts to form a whole system solution. Even so, what has changed substantially is the computing landscape on which software developers construct and release these solutions. Systems are far more likely to be distributed, especially due to the [...]

Architecture DDD Video

 "What is a Coroutine Anyway?" - John Reese

This talk will start with basic concepts of functions, including how they are represented in memory, how state is tracked, and how function calls interact with the stack. We’ll then cover the common methods of running multiple functions concurrently, as well as the benefits and difficulties of concurrency in Python. We’ll then introduce the concept of coroutines, a variant of functions, and discuss how coroutines manage state and execution differently from functions. We’ll show some high level examples of coroutines that communicate with each other, and look at how they can be of use for I/O bound workloads. Then we’ll finish by showing how coroutines are implemented in Python, what the async/await keywords are actually doing when you use them in your code, and how all of these concepts are leveraged by the AsyncIO framework to build high performance applications in modern, clean Python. AsyncIO uses coroutines to deliver high performance from a single thread. But coroutines can be mysterious. How do they work? Starting from first principles, we’ll take a look at the basic concepts of coroutines and the unique problems they solve, then finish by deconstructing the core pieces of the AsyncIO framework. This talk is for developers of all backgrounds. No CS degree required!

Async Python Video

 Python Standard Library: The Hidden Gems

The Python Standard Library is a very rich toolset, which is the reason why Python is stated to come with ""batteries included"". In such an amount of features and tools it's easy to get lost and miss some of the less unknown modules or gems hidden within the whole load of functions and classes. This talk aims at showcasing some recipes, snippets and usages of standard library modules and functions that are less known or that are not covered in the most common books and tutorials available for Python. The talk will try to showcase a bunch of short examples in the hope to foster the ""oh, wow! I didn't think about that"" reaction at least once in the audience. We will see how frequently for tasks where you used third party libraries or frameworks a solution bultin into the standard library is already available, and such solution is guaranteed to be maintained and well working for the years to come thanks to the standard library reliability and stability.

Python Snippet Video