Packaging apps is fun so why should we try to do anything useful out of it?

We love packaging! Running? Not so much. Why bother with the running
part? It looks so fun when those applications are forever locked inside
a virtual brain teaser.

Yes, it's Python, the one and only, the one that made a polytheistical
creationist take on what packaging would look like if it was made just for fun
and not to actually do anything useful at all.

Python's cult leader is Guido, he's the Frankenstein behind the poison that is
PyPa, the evil organization in charge of the Python packaging enslavement plan.
What the plan is all about? Taking over the world by turning Python users and
developers into zombie goblins with no will for themselves and nothing left
except being the main propagandists of this nonsense, time murderer that is
pip et al.

Guido, our dear Guido... His love for snake, tyranny and finally side-effects.

That innocent looking __init__.py file which seems to be at the root of
everyone's despair and worst nightmares.
One does not need to be a functional paradigm puritanist maniac to have hatred
for his one-sided love of side-effects where something as obvious as importing
another source file ends up forcing us into the impossible task of mapping the
entire software life-cycle and its infinite amount of side-effects into our
mind. Almost as if they were looking to introduce some kind of complex
causality.

Another fact is that Python people cannot just simply have a main file, after
all, it is boring, they need to look smart so they're making it (almost) hard
for us, victims of their megalomaniacal tendencies, their version of
"I had bigger plans", to force us into figuring out when where and how their
application of a cult starts, that is, if we don't break before that.

It's a rat race of who can make the most and worse fake DI-looking
application starting process. No surprise there, they won big times.

After all, they'd never run out of idea just like I'd never run out of cuss
words either but it's a pity because I don't have any intention of making a
business out of them.

Python fetishists also do not fancy to have normal looking things such as
a normal looking directory layout, the desire is too strong, they have to try
their best to look like those EBCDIC-era forever stuck developers who made a
living of rewriting and then re-wiring an entire galaxy in an extra terrestrial
yet ancestral architecture with a focus on creating cults within applications.
It is precisely because of this that we have to look and think more than
necessary when we need to analyze or make changes to their alien codebases for
whatever reasons.

People are still going to pretend like it's OK to murder users' time that way.

Just look at about any other normal looking packaging ecosystem and
you'll eventually see that it takes about one command to run the
application, one, unless it's voluntarily made harder by morons or EEE cultists.

The difference with Python is that even when it's made to be easy it still
isn't and that's because one does not simply run Python, you need to metabolize
it. That's right, even though Python applications are interpreted and there's
a huge virtual monster ready to pop up from literally nowhere and with thousands
of years of thinking at his disposal to understand our most despicable codes and
turn it into something actually useful, yet, it cannot simple run it,
it needs our systems to metabolize it. Why? Well..

Why try to make things simple when you can do a much better job
at making them unnecessarily harder?

This non consensual fetish for package distribution that has been going on here
since "Guido is going to save humanity" arc through the "Guido is bored of
tyranny" arc seriously needs to end.

We need the final arc, Python's own Noah's Ark where everyone breaks away from
PyPa. For that plan to happen, a plan to take back the world of snakes, we
need those pythonized goblins taught what abstraction actually means and why
it is certainly rarely a good idea to saturate UX/DX with concerns that are
way out of their scopes.

I simply do not care how the Python app is packaged, why it is packaged and
why god Guido has made it its critical life mission to force people into
becoming brainless maniac that just distributes their Python applications
with no intent of having it running at all, almost like he's Santa, the PyPa
Santa Claus and they're basically its enslaved goblins.

So what can we do about it?

Think about the actual user who is going to have to go through installing your
application, installing should be by far the easiest part.

Time to start not using pip, something else, anything else, anything as long
as it looks and acts like a package manager and does not try to enslave its
users.
There are lots of examples out there so there's not even any real need to
make something up.

People just need unpythonize their minds before it's too late
and they turn into the final stage of them becoming PyPa's zombie goblin
slaves.

After all, we are not the eternal slaves of programs, it should be us using them
not the other way arround.