From there on, it is up to the developer to add their own design and functionality. After you understand the code for setup, routes, templates and user accounts this should be easy.
As for mutliple steps adding to the same file, I think overwriting the whole file every time is doable. For example when we introduce the concept of a template, the template can be created like this:
cat << 'EOF' > templates/index.html
<h1>Hello World</h1>
EOF
cat << 'EOF' > templates/index.html
{% extends "base.html" %}
{% block content %}<h1>Hello World</h1>{% endblock %}
EOFMy whole project is just one page!
The page displays multiple scripts side by side.
One script per framwork.
Each script can turn a fresh Linux installation into a working web application with routes, templates and user accounts.
What are your thoughts on docker which seems to do something similar? Also, how would you stay updated on every single framework if they ever change their installation scripts or other such parts?
Since I envision the scripts to be very small, I expect that updating them will not take long. The history of the updates will indeed be very interesting. In 10 years we can look at it and see how often each framework had breaking changes.
So instead of using debian:11-slim as I propose, one could use a Dockerfile made for Django. But that would help very little. Django even abandoned their official Dockerfile because it brings so little to the table.
In my opinion, using a higher level Dockerfile than the bare OS is a net negative. The developer won't know how much magic it hides. Even though it just hides a few lines of code. And being higher up in the stack also means stuff will break more often and the scripts need to be updated more often.
It's not tutorial-style, but it does contain hundreds of sample web apps (that all do the same thing, but still)
Django==3.1.12
greenlet==0.4.17
gunicorn==20.0.4
meinheld==1.0.2
mysqlclient==1.4.6
psycopg2==2.8.6
pytz==2020.4
ujson==4.0.1
The idea is to format the tutorial for each framework as a shell script. So there is no ambiguity of how to reproduce the results. And it is even possible to just copy&paste the steps into a docker container and see the framework in action.
Here is a demo of how this could look like for Django:
https://www.gibney.org/from_debian_to_web_app
It would be cool to have one column for each framework and then align them visually by feature. So if you want to compare how do you use a template, you can look at the "Let's use templates" row and have a quick overview of how it is done in Django, Laravel, Flask, Symfony, NextJS...
Each framework section could link to the developer(s) who wrote it.
If you want to contribute to the section for your favorite framework, send me a message!