django-learning: A Repository That Grows Up in Public
From `HttpResponse` to template inheritance to Tailwind CSS, this repo turns Django basics into a staged record of how a self-taught developer actually learns.
- `django-learning` is valuable because it exposes learning as architecture, not as a polished demo.
- Each folder marks a real capability jump, from raw responses to modular routing, template logic, and a compiled asset pipeline.
- The template layer is the repo’s turning point because it shows Django logic becoming reusable and legible instead of ad hoc.
- Its rough edges matter because they preserve the sequence of mistakes, fixes, and upgrades that courses usually hide.
Why This Repo Matters
Most Django tutorial repos try to look finished. This one does the opposite. It keeps the learning path visible, so the structure itself becomes the point.
Most people think backend engineering is about learning Node.js, Django, Spring Boot or Laravel. It’s not. It’s about learning how computers communicate. Once you understand HTTP, databases, caching, queues and APIs… Learning a new framework becomes the easy part.
That is the right lens for this repository. It is not trying to prove mastery with one pristine app. It is documenting how mastery accretes, one folder at a time.
A Learning Path, Not a Single Codebase
The nested project names tell the story quickly: `myproject/dj1`, `myproject1`, `myproject10`, `myproject11`. That is not tidy product naming. It is a record of iteration, and the odd artifacts, like a stray `myproject9` folder, make the progression feel honest.
From Hard-Coded HTML to Pluggable Apps
from django.http import HttpResponse
def home(request):
return HttpResponse("<h1>welcome</h1>")That is the first stop on the road. Then the project moves to `include()`-based routing and separate app URLconfs, which is where Django stops feeling like a single script and starts feeling like a system.
The Template Layer Is Where the Repo Gets Interesting
`myproject10` is where the repository stops being a list of lessons and starts feeling like a compact textbook on the Django Template Language. It uses inheritance to reduce duplication, then layers in `regroup`, `widthratio`, `spaceless`, and block filters to show that templates can carry real logic without becoming unreadable.
| Template feature | What it does | Why it matters |
|---|---|---|
| `extends` and `block` | Shares a base layout across pages | Keeps structure DRY and predictable |
| `regroup` | Clusters items by a shared field | Turns flat data into readable sections |
| `widthratio` | Computes proportional values in a template | Lets UI state stay close to display logic |
| `spaceless` | Removes unnecessary whitespace | Shows attention to output hygiene |
| Block filters | Transforms a block of content | Demonstrates that templates can reshape content, not just print it |
The Modern Frontend Surprise
`myproject11` changes the tone again. The repo moves from learning styling through a framework layer to compiling CSS with Tailwind CLI, which is a different kind of maturity. The important shift is not aesthetic. It is operational.
<link rel="stylesheet" href="{% static 'src/output.css' %}">That single line means the project is no longer just serving static styles. It is participating in a build pipeline, and that is the moment a learning repo starts resembling a production workflow.
How This Repository Differs From a Normal Tutorial Repo
| Aspect | django-learning | Conventional tutorial repo | Why it matters |
|---|---|---|---|
| Learning style | Visible progression across multiple project stages | One polished starter app | Shows how understanding accumulates |
| Structure | Nested folders and version jumps | Single clean codebase | Preserves the sequence of experimentation |
| Architecture | Moves from responses to routing to templates to build tooling | Often stops at a single pattern | Reveals more of Django’s real surface area |
| Frontend | Bootstrap-era learning evolves into Tailwind CLI and compiled CSS | Usually one styling approach | Shows that frontend tooling can mature alongside backend skills |
| Educational value | A living notebook of mistakes and upgrades | A finished example to copy | Teaches process, not just outcome |
What the Repo Teaches Better Than a Course Does
A course often smooths out the awkward transitions. This repository keeps them. That is why it is useful. It shows that learning Django is not a straight line, and that rough edges are often the clearest evidence of real progress.
