Tools as teachers

Software education sometimes seems like a bit of a commodity. There are a million courses and bootcamps promising to let you buy "mastery" of different technologies. So producing and selling technology-focused software development courses is risky.

Is it possible to run a course focused on a specific tool or technology without becoming "just another one of those"?

A lot comes down to the goal of a course, the mindset behind it.

Django is a good teacher

Some tools are good teachers, some are not. I'm a big fan of Django specifically because it is a great teacher.

If you get good at writing Django code then you'll learn a lot about web-development along the way. That knowledge is very transferable. A lot of web frameworks have borrowed from Django's way of doing things and so many web development frameworks feel familiar by default.

This holds true even when coding in different languages. For example, if you decided to write an application in ExpressJS after knowing Django, you would be able to jump in really rather quickly, even if you didn't have much JavaScript to your name.

Django is a good teacher because it is opinionated. Many people find its opinionated nature a bit frustrating to work with, but it's important to remember that the opinions built into the framework were put there by people who really know what's up.

If you learn from Django, you learn from giants.

Django is also a good teacher because it is explicit. It limits the behind-the-scenes "magic" to a bare minimum. There are very standard ways of structuring Django applications, but it's really quite flexible.

Some frameworks lean into the "magic" way too hard to be very good teachers. Some frameworks need you to put things in the right places and give them the right names and follow the conventions and then the magic just happens. And when the magic doesn't happen correctly then things get pretty weird.

With a tool like Django it's pretty clear where the code is running. What's happening on a server, what's happening on a client. How the server and client pass information back an forth.

With some frameworks that isn't even clear. It's hard to know where the code is running or even if it only runs during an opaque build step. It just seems like magic. Magic with quick wins perhaps, as developers can get things to run pretty quickly without much thought, but it does cause problems.

For example, I met someone who could confidently build React applications but was not able to fully reason about where one technology started and the next began - React, Tailwind and VSCode were all labelled as "React" in their brain, or a part of React. But they could make the code do things.

Django is also a good teacher because motivation matters, as in, the motivation of the students. You can get some pretty quick wins in Django - it's the framework for perfectionists with deadlines for a reason. You can build stuff fast.

There are a lot of quick wins to be had early on in learning the framework, and there are enough batteries included that it takes the edge off most of the boring and repetitive parts of building an application.

People often get a bit intimidated by Django's learning curve - but the learning curve teaches a lot more than just Django.

Django AllAuth is a good teacher

If a person wants to double down on Django and become quite good at it then it's worth being able to build applications with solid authentication. And building authentication mechanisms from scratch, while interesting, is generally considered a very bad idea.

Authentication is a cornerstone of a secure application. You need to keep your users and their information safe. And solid authentication has a lot of moving parts and there are a lot of decisions to be made, then built, then tested.

AllAuth is fantastic because it does a lot out of the box:

• username/email and password authentication
• social account authentication, with support for LOTs of providers
• multi factor authentication
• registration
• email validation

And it does it all in a way that is highly customisable out of the box. It even handles internationalisation!

The reason AllAuth is a good teacher is because integrating it into a Django project, configuring it so it does what you want it to, and getting it to look on brand is an adventure.

It's an adventure into the AllAuth code base, and into it's docs.

If one were to write a simple AllAuth tutorial that covers AllAuth integration it would either be very surface-level and simplistic, or it would only cover specific use cases and design choices.

An AllAuth course could hold your hand and keep things straight-forward and get you to a point where you can plug things in without considering things too deeply.

Or it could aim to help you become the kind of person who could figure something like AllAuth out.

It could get you comfortable with experimenting with different settings and digging into the code, it could get you to a point where you understand exactly what templates to override at a minimum to get your stuff to work and look the way you want it to. It could get you familiar with the AllAuth code structure and design decisions.

It could give you the tools to understand, and not just do.

Because then you would understand a lot more than just AllAuth.

HTMX is a good teacher

HTMX is a good teacher because it brings interactivity to the web in a way that keeps you grounded in the fundamentals of HTTP and HTML. Unlike JavaScript-heavy frameworks that often obscure the underlying mechanisms, HTMX is low level enough that you can see and reason about exactly what is happening at all points.

It's explicit. We like explicit.

With HTMX, you learn to appreciate the power of standard HTML attributes while enhancing them with minimal JavaScript. It teaches you how to handle requests and responses efficiently without hiding the process behind complex abstractions. You’re forced to think about the structure and flow of your application, understanding the nuances of GET, POST, PUT, and DELETE requests.

Moreover, HTMX keeps you connected to the server-side logic. It doesn’t create a hard divide between the front end and back end, which means you gain a holistic view of how data flows through your application. This full-stack perspective is invaluable, especially for beginners who might otherwise get lost in the complexities of modern JavaScript frameworks.

HTMX gets you to practice the direct use of the underlying web technologies.

Tools that are good teachers could also be good tools

The technologies listed above are not toys. They are solid, respected, technologies used in production by people and organisations that are fully hard-core.

If a tool is a good teacher AND it is genuinely useful and has a shelf-life then it's a winner. If the knowledge of a tool is useful in it's own right, worth pursuing in it's own right, AND it makes you a better developer... well, that's pretty cool.

Shameless plug

I've recently released a new workshop on Django AllAuth. You can find it here.

In this article, I shared a little bit of my thinking on how the workshop was designed. If it sounds useful to you, get yourself a ticket.

Also, if you can't afford a ticket, please reach out. I do make a point of helping where I can. Most of my clients are in America so I charge reasonable American prices for what is on offer. But I want to open doors. I'm not in a position to give a lot away for free right now, but I can handle some discounts. Reach out and tell me about your situation and I'll see what I can do!