If you don’t want to read the whole article, it starts with this summary:

Django, not Flask, is the better choice for beginners’ first serious web development projects.

While Flask’s simplicity and clear API make it great for learning and suitable for experienced developers, it can mislead beginners about the complexities of web development. Django, with its opinionated nature and sensible defaults, offers a structured approach that helps novices avoid common pitfalls. Its comprehensive, integrated ecosystem is more conducive to growth and productivity for those new to the field.

People won’t let go, they won’t accept that the paradigm of rails is a bad idea. They see flask and similar libraries eating their lunch and come up with these contrived made up reasoning that cannot be put to test.

Every single django codebase I have seen have became unmanageable, most of them have been replaced. We know the reasons nowadays but some diehards don’t want to let go for nostalgic reasons.

Back in the day, rails, Django and similar were a quick way for a beginner to have access to quite a lot of useful things. The web development ecosystem has matured tremendously, such things can be mixed and matched at will, without the need for a gigantic decision lock called Framework, that will essentially get in the way of adding unexpected functionality.

The oficial python documentation covers how to use usgi and asgi as well as the SQLite module, that is where beginners should start. They will get results an order of magnitude quicker than if they start learning django.

This reads like all those perl and PHP posts. They had their time and they were great. We can even learn something from them and might still be useful in specific situations. But things have evolved.

I’ve never had a project that involved building the kind of app that Django wants to be used to make.

I do enjoy Django more than Flask because it is batteries included and opiniated (making my own decisions is exhausting). If you really want the FastAPI experience, there is django-ninja.

In any case, sprinkle some htmx on top of that, and you get a nice SPA without React/Vue/whatever :)

There is even django-htmx for a nice integration in views and templates.

The Django ORM fulfills 95% of my use cases, I don’t need something more powerful.

And for those remaining 5%, let’s not forget that the Django ORM provides unmanaged models. Using PostgreSQL views to abstract complex queries and then creating an unmanaged model for it is often the way to go. And if you don’t mind the occasional raw SQL, PostgreSQL’s stored procedures/functions are there too.

The only real downside to Django’s ORM is that its async API is still a PITA: async code can’t be called from sync context, but sync code can’t be called from async context either. This means that for those models:

class Foo(models.Model):
    pass

class Bar(models.Model):
    foo = models.ForeignKey(Foo, on_delete=models.CASCADE)

The following code will not work:

bar = await Bar.objects.aget(pk=1)
foo = bar.foo # sync call

And has to be replaced with:

# pseudo-code, i don't remember the exact syntax
bar = await Bar.objects.aget(pk=1).prefetch('foo')
foo = bar.foo # no sync call, prefetched

Here I am hanging out with Bottle and having fun. Flask is HUGE in comparison.

I tend to agree. On the other hand, doing a small project in Flask that quickly gets out of control teaches you why you want to use the MVC patterns, etc. Once you have internalized the patterns, you don’t need Django anymore, but it is helpful to have a place to learn it from and trying to go it alone and failing also gives you the motivation to learn it.

One way to think about it is when to use which in the learning process. For a student doing independent study in university, Flask is probably fine for making a small mess. For a junior dev at a company, you want Django so they don’t screw up the company app and you can give them books to read to learn the basics.

I could not disagree more.

Flask is the best place to begin and build out your knowledge. You aren’t going to learn anything if you’re frustrated and stuck in just getting a “hello world” running. Flask lets beginners dive right into learning web requests without the “opinionated” bloat. For large projects, sure, pick something more robust, but I learned how to build apis and web apps with Flask from day one and I appreciate how simple it to this day.

Django has an opinion. Like all opinions, it is debatable, but when you start web dev, your opinion likely sucks

This is why I agree. I can understand an argument that Flask is simpler and thus provides a smoother learning curve, but Django’s upfront complexity can solve the “I don’t know what I don’t know” problem. I would have never learned what CSRF attacks were nearly as fast if I didn’t have to debug error messages about them at my first job.

I don’t think a beginner should work with a framework where you have dozens of auto-generated files and can’t understand what 90% of them do without spending hours reading documentation.

But web development is not simple. It is filled with little traps, you have to make a ton of decisions right…

However flask assumes you know. It has a small feature sets, and is not very opinionated. To use it correctly, you have to know what you are doing.

I’m curious what the author thinks a “beginner” should be doing and learning exactly. In my experience, a beginner should be making mistakes, they should be confronted head on by complexity which they didn’t expect, they should be learning…

But the newcomers I met that put Flask in prod for their first projects get scars from it.

This is an even weirder observation, who is letting loose these noobs to develop and learn in a vacuum and then deploy to prod?

My A level computer science non-exam assessment project was a web application in Flask. I never actually completed it (traditional methods of assessment were abandoned when coronavirus happened) but I found its documentation to be excellent for a beginner. I don’t think I’ve found any documentation as easy to read, navigate and learn from as Django’s since.

But when I, about a year later, tried to teach Django to someone I was tutoring one-to-one over the Internet, I found it difficult to get the concepts across. My tutee had taken quite well to the general concepts of Python programming up to that point; I think the problem might have been that they didn’t understand the reason why what they were learning (the layout of Django’s files) was so much more complicated than what they were doing before. When I had learned Django, I had learned it using the tutorials which are part of its online documentation, which gave me a reasonably good theoretical introduction to MVC. But with my tutee I focused on the practicalities. I didn’t know Flask at that time but I might have used it instead if I had.

/me cries in custom SQL generator because Django ORM can’t JOIN and everyone keeps repeating “you must have a wrong problem because Django is the perfect solution”.

It seems to me that Django has painted itself into a corner interface-wise and now any improvement will require major refactoring that will break a lot of production stuff for a majority of users.

When I was learning web development back in 2010, I evaluated Ruby on Rails, Flask, and Django. Flask was the right place to start for two reasons: First, it was small. I had a much easier time figuring out what the important parts of the framework were. Second, I found the Flask documentation much easier to understand than everything else. It had a tutorial that didn’t assume prior knowledge of web development or the MVC pattern. It went into detail on each and every part of the framework. I remember it being pretty wonderful.

I ultimately ended up going with Rails, but reading the Flask docs on similar patterns and concepts first made getting started there much easier.

I agree that Flask is probably the better starting point for beginners. I find the sheer amount of files + stuff presented to you out of the box with Django can be intimidating.

Developers will write unmaintainable Django apps and people will use this as an argument to switch to Flask. They’ll also write sprawling unwieldy Flask apps and wish they’d had some of the guardrails of a framework like Django.

I’d say it completely depends on the project. At my $work we’re very happy with Flask + GraphQL (Ariadne + SQLAlchemy) because we’re not really dependent on any Flask extensions.

For personal stuff I’ve been able to bootstrap stuff much faster with Django because I made a conscious decision to embrace/utilise the framework. I.e: use the admin, use their built-in auth, use django-celery integration etc. When you’re trying to hand roll all those integrations in Flask it becomes a real pain.

Actually, beginners should use Quart, not Flask and definitely not Django.