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 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.

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 minds.

almost as if they were looking to introduce some kind of complex causality.

That innocent looking __init__.py file which seems to be at the root of
this world's entire despair.

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. 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
is exactly why we have to think more than necessary when analyzing their source
code.

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

Just look at about any other (earthly) 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 and for that a plan needs to be drawn, a plan to take back earth, by
summoning the smartest people and force them into teaching Pyhonized goblins
what abstraction means and why we should not saturate our UX/DX with concerns
that are way out of their scope. I simply do not care how the Python app is
packaged, why it is packaged, why god Guido has made it its critical life
mission to force people to distribute their Python applications almost like
Santa, the PyPa Santa Claus, and they're basically its enslaved goblins.

So what can we do about it?

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

Time to start not using pip, something else, anything else, anything as long
as it looks and act 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.