Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
Python Is Not A Great Programming Language

Python is not a great programming language.

It's great for beginners. Then it turns into a mess.

What's good

  • A huge ecosystem of good third-party libraries.
  • Multiple inheritance.

What should be good

  • It's easy to learn and read. However, it's only easy to learn and read at the start. Once you get past "Hello world" Python can get really ugly and counterintuitive.
  • The Pythonic philosophy that "There should be one -- and preferably only one -- obvious way to do it." As someone who loves working within rules and rigid frameworks, I love this philosophy! As someone who writes Python, I really wish Python actually stuck to this philosophy. See below.

What's "meh"

  • Forced indentation. Some love it because it enforces consistency and a degree of readability. Some hate it because it enforces the wrong consistency. Objectively it's neither good nor bad.
  • Dynamic typing. There are lots of dynamically-typed languages and lots of statically-typed languages. Which kind of typing is better isn't a Python debate, it's a general programming debate.

What's bad

  • 400 ways (more or less) to interpolate strings. This prints "Hello Robin!" 3 times:

    user = {'name': "Robin"}
    print(f"Hello {user['name']}!")
    print("Hello {name}!".format(**user))
    print("Hello %(name)s!" % user)

    If there was a unique and obvious use-case for each of these then that would be one thing, but there's not.

  • 69 top-level functions that you have to just memorize. GvR's explanation sounds nice, but in reality it makes things confusing.

  • map doesn't return a list, even though the whole point of a mapping function is to create one list from another. Instead it returns a map object, which is pretty much useless since it's missing append, reverse, etc. So, you always have to wrap it in list(), or use a list comprehension, which, speaking of...

  • List comprehensions are held up as an excellent recent-ish addition to Python. People say they're readable. That's true for simple examples (e.g. [x**2 for x in range(10)]) but horribly untrue for slightly more complex examples (e.g. [[row[i] for row in matrix] for i in range(4)]). I chalk this up to...

  • Weird ordering in ternary/one-line expressions. Most languages follow a consistent order where first you declare conditions, then you do stuff based the on those conditions:

    if user.isSignedIn then user.greet else error
    for user in signedInUsers do user.greet

    Python does this in the opposite order:

    user.greet if user.isSignedIn else error
    [user.greet for user in signedInUsers]

    This is fine for simple examples. It's bad for more complex logic because you have to first find the middle of the expression before you can really understand what you're reading.

  • Syntax for tuples. If you write a single-item tuple (tuple,) but forget the trailing comma, it's no longer a tuple but an expression. This is a really easy mistake to make. Considering the only difference between tuples and lists is mutability, it would make much more sense to use the same syntax [syntax] as lists, which does not require a trailing comma, and add a freeze or immutable method. Speaking of...

  • There's no way to make dicts or complex objects immutable.

  • Regular expressions require a lot of boilerplate:

    re.compile(r"regex", re.I | re.M)

    Compared to JavaScript or Ruby:

  • The goofy string literal syntaxes: f'', u'', b'', r''.

  • The many "magic" __double-underscore__ attributes that you just have to memorize.

  • You can't reliably catch all errors and their messages in one statement. Instead you have to use something like sys.exc_info()[0]. You shouldn't have a catch-all in production of course, but in development it's very useful, so this unintuitive extra step is annoying.

What's bad about the culture

Most programmers will acknowledge criticisms of their favorite language. Instead, Pythonists will say, "You just don't understand Python."

Most programmers will say a piece of code is bad if it's inefficient or hard to read. Pythonists will say a piece of code is bad if "it isn't Pythonic enough." This is about as helpful as someone saying your taste in music is bad because "it isn't cultured enough."

Pythonists have a bit of a superiority complex.

Copy link

greypanda commented Dec 15, 2021

This thread should be a book! It's hard to believe my first post was 2 years ago. I made some comments that were my opinion at the time, but more experience means more opinions.

I recently took on a project on a Raspberry PI. Python is considered one of the "ideal" languages for that, since C/C++ compilations can take hours to complete. Although I finished the project, I am not proud or pleased with it. xennex22 hit the Python nail on the head. I'm considering rewriting the app in C++ just to get it running reliably.

So have I completely abandoned Python? No. I think it is still a great tool for getting a basic concept running. You just put the code in a file and run it. But for a "real" application, it is just too clunky to bear.

There are way too many "blessed" libraries that are written by beginners and fail the stress tests. I find myself rewriting much of the code in libraries and just using the pieces I need. ( This is not much better than the libraries in Arduino, which have to be carefully weighed before they are trusted. But maybe they can be forgiven since they are free and written by and for hobbyists. )

I was originally impressed by pipenv since it did away with a lot of the confusion of venv, pip and friends. But then I have to ask "why do I need to have 5 different versions of Python running along with the crazy dependencies that presents?" That is one of the reasons I learned to hate Java -- it seemed like every program required a special minor version to even compile. Every time I forget to prefix a command with pipenv run, I cuss.

So since I am no longer paid to make stuff in the image of the program manager, I am really trying to find a language that is not ugly, performs well, and can run on just about any platform. Good luck to me.

Copy link

ekeyser commented Dec 15, 2021

As was so concretely and colorfully illustrated by Shayne Oneill, the Python community has its fair share of zealots who find no value in the opinions of others. About the only other community that is/was similar is Perl but at least w Perl they don't pretend that their language isn't archaic or possibly even obtuse. I find it odd that even with so many people pointing out shortcomings with Python that die-hard Python developers will dismiss anyone with any amount of criticism with such extreme rhetoric. I guess everyone else is simply no on their level.

I guess the next topic is what programming language has what kinds of users and enumerating all behaviors and characteristics of each community. ;-)

Copy link

xennex22 commented Dec 21, 2021

And here's some more reasons not to use Python

  • Energy inefficiency. A recent study shows that Python uses 75 times as much energy to accomplish the same goal as would a C program. Think of all the data centers with banks of servers running Python, and the amount of wasted energy that results in.
  • The stupid backward conditional expressions. I'm not sure who thought the assignment should be before the condition, but it makes reading code difficult (but still the dogma that python is simple and clean and easy to understand persists).
  • The reliance on third party tools to fix the broken language. Since dynamic languages can't find type problems until runtime (if at all) then you are told to run a code audit tool like pyrama. Of course, the linters are written in python so select the one you want to use carefully because they are slow. Same with the stupid reliance on white-space for scope - if you criticize it you are told that you should be using tool x (or even that it is somehow purer and therefore better than using braces).
  • The response from the python cultists, as demonstrated in this thread, that any criticism of python means that you are deficient as a programmer or you are doing something wrong or you just don't understand python or you are not using the right additional hack tool to fix the broken language.

Copy link

xennex22 commented Feb 5, 2022

Guido is an arrogant hack. He created a second rate scripting language which languished for a decade before by pure luck it was adopted by Google.

As an example, here is Guido's take on Python vs C++ (direct quotes):
"Python code is ... often 5-10 times shorter than equivalent C++ code"
"one Python programmer can finish in two months what two C++ programmers can't complete in a year"
Q: "Is C++ better than Python?" A: "If you have to ask, learn Python."

How arrogant do you have to be to claim with a straight face that a Python program is 5-10 times smaller than a C++ program? Or that programming productivity is 12 times high in Python than C++?

"An Empirical Comparison of Seven Programming Languages" finds that writing a program in a dynamic scripting language (Perl, Python, Rexx, Tcl) takes half as long as C/C++ and about half the length. The paper does not explain why the C and C++ programs were the same length and took the same time to write. The number of defects (ie quality) of each language was about the same. I would note that the example program was realitively small and involved string processing, something that favors dynamically typed scripting languages.

"A comparison of common programming languages used in bioinformatics" shows that Python was 90% the length of C++ and about 50% the length of C.

"On the Impact of Programming Languages on Code Quality" shows quality is about the same too.

So boom goes the dogma that Python programs are higher quality (one look at the source for most of the libraries would tell you that). And also we can reject the claims that Python programs are an order of magnitude smaller and an order of magnitude quicker to write.

Copy link

Preposterone commented Feb 9, 2022

Nice read, I have recently tried to delve into Python when learning algoritms and I was STUNNED by the fact that python doesn't have a simple one-line way to write an indexed for loop. Instead, every for is a for each with top-level range() or enumerate().

Copy link

grandslammer commented Feb 10, 2022

I recently thought I'd give Python a try and was getting frustrated with several things about it, so I Googled and found this post. Here's what I really don't like about it, and these are really starting to put me off it entirely:

  • Multiple Python versions installed on my PC (forget about v2 vs v3, I'm talking about multiple versions of v3!)
  • Package management hell
  • Virtual environment hell
  • Whether to install vanilla Python (direct from the website), or Anaconda - possibly both!
  • I'm beginning to get slight feelings of "this thing is trying to take over my PC!" (see points above)

Feels terrible from an organisational point of view.

With any other language I've used, if there's an update to the language, you just download it and it replaces the old version on your system. No messing around with multiple versions of the same language.
The same goes for updating packages - e.g. you just run "npm update" inside a project's folder for JavaScript, and boom! It's done.

Forgive me if there are easy fixes to the above, I'm still new to Python. I've looked and cannot find any resolutions anywhere though.

Copy link

ekeyser commented Feb 10, 2022

That reminds me of the completely hilarious abandonment of pip search support....

xmlrpc.client.Fault: <Fault -32500: "RuntimeError: PyPI's XMLRPC API is currently disabled due to unmanageable load and will be deprecated in the near future. See for more information.">

Yeah, like pip is the only thing on this planet that receives a lot of traffic. Embarrassing. "hundreds of thousands of search calls per hour". Awww, you poor little victim ;-)


Copy link

xennex22 commented Feb 14, 2022

  • The inability to retain backward compatibility between versions. Sure, languages like C++ evolve with standards, but I can take C source from 30 years ago written under C90 and it still compiles and works just fine under C++17. Backwards compatibility is a thing.
  • Assignment expressions. aka the walrus. To fix an original design mistake there now have to be two operators to do the same thing - assignment and expression assignment. No reason not have done it right in the first place.
  • Python only works in a narrow niche. Mobile, embedded, even desktop are not practical targets for Python. Why now? Because of the speed and memory requirements this language has.
  • Scoping was inefficient and when it got fixed it is now half broken. So you end up with things like a function being able to see variables from outside scope but not make changes to them. And Python is touted as the beginner language which is easy to understand. Not when there are gotchas like this.
  • Default arguments have a life and are mutable so become something other than the default value on subsequent calls. As above, why this non intuitive behavior?
  • Python makes a big deal about leaving out ++ and -- operators because they are 'not easy for beginners to understand' but includes +=
  • True and False are hacks for integer values
  • Lambdas are very restricted in that they have to be an expression and are limited to only one line. So you have to create a function and call that in your lambda expression, which more or less defeats the point of a lambda.
  • The development of a fix it culture around Python. eg Frustrated by incompatibility between Python versions for deployment? Use containers. Can't determine the logic flow if a program because of the invisible elements? Use an editor which shows tabs for you.
  • The hacks needed to cope with the 10000 faces of python versions. eg from __future__ import xxxxx. The only one I want to work does not work from __future__ import braces. And of course, it is not an import at all but uses the import keyword ie it is a hack. Also note the use of not one but two sets of double underscores.
  • The hacks needed to work with a dynamically typed language. eg how is / and // initiative to beginners? Also note that the introduction of the floating point division // broke old code. A cast is clearer because at least a beginner would have some idea what a float might be.
  • The 50 odd built in functions that break any object orientated structure to python. eg len(object) rather than object.len(). But then objects in Python are a cruel hack - looking at you self.
  • There is no forced structure to a python program. Thus people program all sorts of crazy things like mixing inline code along with code in functions. No wonder the quality of most libraries is low. Not everyone should write code that others depend on.
  • The prolific use of assert as a non debugging aid in release software. That would bring me on to the next problem with using Python in a commercial environment - the lack of a pre-processor.
  • Why is python written in C/C++ if C is so bad? You can implement a new language from any other by first writing an interpreter and using that to write a compiler. The interpreter is there, so why no compiler to compile the python written interpreter?
  • The more you look the clearer it is that python is an ugly hack of a language. The emperor has no clothes.

Copy link

isaax2 commented Feb 23, 2022

I'm happy that I'm not alone, I develop apps in since about 15 years in lots of languages and layers (C, C++, C#, Java, Objective-C, Swift, Javascript, LUA, Ruby ... etc). Now I took Python with an existing real project, and it's the first time that I can barely understand what's happening using the "simple and easy syntax".

Copy link

Odalrick commented Feb 24, 2022

map and enumerate do not have the same methods as list

Can someone explain to me exactly why completely different things should have the same methods?

And another thing:

single-item tuple (tuple,)

I know about the syntax for a single item tuple, and can even agree that it is an easy mistake to make; but for the lite of me I cant think of a single time when I'd actually need a single item tuple.

It's almost as if the thinks the only difference between tuples and list is that one is immutable; but no-one can be that silly can they?

Everyone knows tuples are fixed collections of heterogenous things and lists are variable homogenous collections.

Copy link

codingben commented Feb 27, 2022

@isaax2 Same here. I'm a developer with more than 10 years of coding - I never saw complicated language like Python, it's like a different world and very hard to keep it "simple" when your application become bigger and bigger (especially when it comes to PyTest, Typing, etc). Just see [1] how it's complicated.

I can confirm that Python is much much more complicated than Rust. 😄


Copy link

Reenuay commented Apr 9, 2022

Just learn functional statically typed language and you will understand that all those mainstream languages are the same sh*t. For example, you can learn Elm. After that I don't want ever write a project with a non-functional language.

Copy link

BrianG61UK commented Apr 22, 2022

Dynamic Typing.
How can a language that doesn't identify type mismatches at compile time be considered anything other than a toy.
Mistakes in syntax can go unnoticed until they just happen to crash your program at some random point in it's life time.
It's almost as hopeless as the Microsoft Basic was on the first computer I owned as a teen back in the 80s.

Copy link

StitiFatah commented May 7, 2022

Dynamic Typing. How can a language that doesn't identify type mismatches at compile time be considered anything other than a toy. Mistakes in syntax can go unnoticed until they just happen to crash your program at some random point in it's life time. It's almost as hopeless as the Microsoft Basic was on the first computer I owned as a teen back in the 80s.

Copy link

tworthington commented May 8, 2022

Copy link

BrianG61UK commented May 9, 2022

I don't think I've had a runtime type mis-match error this century, and I mostly code in dynamically-typed languages. I suppose being able to check at compile time is perhaps a nice to have, where it can actually work, but if it's saving you from bugs routinely then you're doing something else wrong. Probably writing functions/blocks/methods which are too long so you lose track of what you're doing. Python has many flaws, but dynamic typing isn't one of them and adding it won't help.

You never have complicated global data structures and many people writing code that manipulates them?
When the data structures get modified to add new features, you never miss any of the changes needed in any module?

Copy link

nslay commented Jun 23, 2022

I love how I can crash my Python scripts in ways you can programs written in native languages. Messages about segfaults and double-free corruption are things you wouldn't expect to see with Python. The worst I've seen to date is silent memory corruption... wow, I just never thought I'd see that in Python! Only knowledge about a native language can provide any clue as to why these kinds of crashes might have happened (and how to workaround or fix them in Python). A newbie computer user isn't going to understand, for example, numpy memory trickery and all the things that could go wrong if numpy doesn't account for shared memory correctly.

Maybe my gripes are more directed toward Python packages. Where do you draw the line between essential packages like numpy and Python, the language? I think numpy played a very big role in Python's popularity. Yet you can really shoot yourself in the foot in worse ways than described in this article. Like C levels of foot-shooting! And it's more mysterious because of how convenient and high-level the language is.

Copy link

rednnnno commented Jul 1, 2022

The more I think about it, the more the forced spaced scopes remind me of the COBOL/RPG400 days...

I guess it's to be expected; we went from mainframes -> Personal computers -> cloud computing (really just back to mainframes - but on the internet now...)

So I guess it's just a fashion and it works exactly like fashion; concepts are cool for a few years; mostly forgotten about a pulled from the moth-balls back to relevance by some nostalgic geezers and/or some younguns that've never seen it before.

Copy link

masonova1 commented Jul 19, 2022

I want to leave this gem here:
Python equivalence to inline functions or macros (SO link)

Check the first answer, and witness the intersection of Python's optimization philosophy with Python's modularity philosophy.

It's somewhat old, but this sentiment with regard to performance problems still seems very present in the Python community. I'm convinced that this attitude will be the downfall of Python's industry prevalence, so long as none of the people at the round table can agree on how to improve this through language features instead of packages and modules.

Another problem I've noticed is that it is excruciating to convince Python developers in the first place that useful, ubiquitous concepts as simple as drop-in, expandable "macros" are deserving of optimized implementations, or even a language keyword or two. Every Pythonic solution I've heard to this, even when it's not just "don't worry about it", sounds astonishingly worse than just implementing the feature; As a programmer, I should be able to guarantee to at least my own interpreter that "yes, this static, unchanging macro with no state will be defined by the time you encounter something that needs it. If it hasn't, throw me some error about it."

With specific regard to the macros/inlining problem, I find arguments of the form "this is too complex to distinguish from regular functions for Joe Schmo the Python developer" to be implicitly patronizing to their own community and pretty unsatisfying as a justification for just not having anything like this.

Edit: I should add that the existence of the Inliner module is not even a solution to the specific problem as I stated it -- the Inliner does not "add macros/inlining to Python", it implements macros/inlining as a modular dependency. This is precisely the absurd collision of modularity philosophy and optimization philosophy that I hinted at earlier.

Copy link

AkashicSeer commented Jul 26, 2022

As an end user Python sucks ballsac because of the multiple versions. Often as you are following along something online it tells you something like use "pip --python-sucksnutsac" and you get some error that pip doesn't exist.
So you have to google and dig and find out that you now need "python3-pip" Ok so you install that BS and try to run the command only to find out that "python-sucksnutsac" is not installed, you try to install it, but the new name is different or it doesn't exist.

All these hours wasted and all you wanted to do was use ansible to automate an installation. But you find out that to create a new linux user with a password, the password needs to be encrypted with the horrible shit language known as python because ansible is written in the shit language of python.
The biggest nutsuckery of python is the significant indentation. That is by far the dumbest, most time wasting shit anyone ever came up with. I can't imagine how much time is lost when programming with Python just trying to make sure all the indentation is right .Significant indentation is why I hate YAML. Significant indentation is why I dumped Scala.

Copy link

ekeyser commented Jul 26, 2022

That was entertaining and I can't wait for the python fanbois to be triggered. I agree indentation requirements are pure annoyance - basically forced training wheels. I'm not sure why any language forces indentation. Is it a sort of equivalent to logic/conditional/loops type-safety (or type-strictness)? That's my guess. "Oh, gotta make sure your if statements line up or you could do something bad!"

python2 and python3 are for all intents and purposes different languages. At least they differ enough and typically cannot be executed using the other interpreter without problems, errors, warnings that I just consider them to be completely different languages and yes a lot of this bleeds over into the packages and cross-python package incompatibilities. python3 should've been backward compatible with python2 - not sure why it wasn't. Feel like that was just yet another poor design decision.

Could the same be said for node/js and the different versions and standards there? I suspect so but w js you have what I believe is a standards body overseeing the publishing of the ECMAscript versions. And I believe (I could be wrong) you can run old js with new ECMAscript engines (or versions of node). With Python you just have an arbitrary decision by the language developers. And iirc there wasn't much of a deprecation or roadmap so what you ended up with was essentially 2 versions of every python app or one version or the other. I sort of have a hard time believing they couldn't maintain support for previous versions of the language.

Every language evolves over time but for some reason the Python way feels incredibly disjointed.

Copy link

fralligator commented Jul 30, 2022

dont use python
i only picked this shit language up because i need it for data science because physicists are fanboys of a shit language try coming from kotlin which is insanely fast, never get errors beautiful 20 years of learned errors corrected into the language from other languages then coming to python just to discover you never really know why you get an error it could be something utterly lame like simple spaces because of their utterly worthless scope decision O_o because they thought removing "{ }" or using ":" (omfg) would be a good idea they also use this utterly useless ____ case all the time with classes whereas camelcase utterly superior the type libraries is all messed up tbh fucking pain really hope kotlin destroys this worthless language or GO which is the next best alternative other than kotlin for data science

Copy link

openbakk commented Aug 10, 2022

Phyton is life!

Copy link

AkashicSeer commented Aug 11, 2022

Recently I opened up a decade + old PHP program I had written. It was in PHP version 5.3. I ran the code on PHP 8 NO PROBLEM. The same project had 10+ year old Javascript. GUESS WHAT????? IT ALSO RAN WITH NO PROBLEMS. People like to repeat the old BS about PHP But at least it WORKS. At least it has the concept of "private, protected, public" for variables and class methods/functions. At least PHP is Backwards compatible and doesn't constantly break shit just for the sake of breaking shit. At least it is Type Strict, you can type hint the Method arguments which REALLY, REALLY REDUCES ERRORS. Modern PHP is like the twin of Java without all of the double/triple typing.

Python feels ULTRA AMATEUR. Like it is maintained by people that have never taken courses in Computer Science, programming etc. It is like a toy language due to this BS.

Every last F***ing time I go to use ANYTHING WRITTEN IN PYTHON I end up having to waste an hour or more dicking around googling, trying 100 commands on the command line seeing errors galore, getting more and more rage pissed that some idiot who had never used a real programming language decided to write an Entire program in a POS language that isn't even coherent, cohesive, backwards compatible etc. etc. etc. etc. etc. etc. etc. I can't stand wasting so much time trying to get BS working.

I left PERL 10 years ago when they did the same BS Python did with breaking compatibility. It just makes shit suck when idiots who maintain a language do such stupid shit.
Want to do machine learning use RUST. Use anything but Python. Please stop creating shit with python, it is too much of a pain in the ass for end users.

Copy link

SanzSeraph commented Aug 11, 2022

Ruby is streets ahead of Python to my mind.

Don't you mean "rails ahead"?

Copy link

CLanguagePurist commented Aug 16, 2022

Going to toss my hat in the ring about what I have to say about Python.

Python is the most painful language that I have to deal with when working on Linux especially as an End User Perspective. There is absolutely no benefit to using Python from what I can observe in contrasts to literally every other programming language out there and I have worked across most programming languages, you name it, C/C++, Rust, DLang, Java, C#, Perl, Ruby, Javascript, Erlang, assembly, and more. Nothing stick out like a sore thumb like Python compared to all of them.

The most central problem with Python is ironically it's best aspect, the ecosystem itself. The problem is that the program that were shipped on Github, about 99% of the time, they fail outright, because they needed that one particular version of dependency to be made available, or that time progresses long enough that we end up having something like this:

        [ Program ]
             /    \
           /        \
       [A]        [B]
        /              \
      /                  \
   [C Ver 1]        [C Ver 2]

You have something like Dependency A and B relying on sub-dependency of different versions and they cannot use one newer/older than the other, they have no flexibility and demand THAT ONE PARTICULAR VERSION ONLY! Python folks obviously tried to fix it by "packaging" it into a virtual environment or using Conda, but all of those fail too no matter what. Sure, you could literally go in and try to fix them yourself, but another bug pop up and another and another and another, it just won't end.

Here the log I get from trying to simply run "pip install conda" on a fresh Linux install.

      Traceback (most recent call last):
        File "<string>", line 2, in <module>
        File "<pip-setuptools-caller>", line 34, in <module>
        File "/tmp/pip-install-1wm2gmmv/conda_a01b278ecedc41b2a0fa3e7046717acf/", line 35, in <module>
          import conda._vendor.auxlib.packaging  # NOQA
        File "/tmp/pip-install-1wm2gmmv/conda_a01b278ecedc41b2a0fa3e7046717acf/conda/", line 13, in <module>
          from .common.compat import iteritems, text_type
        File "/tmp/pip-install-1wm2gmmv/conda_a01b278ecedc41b2a0fa3e7046717acf/conda/common/", line 77, in <module>
          from collections import Iterable
      ImportError: cannot import name 'Iterable' from 'collections' (/usr/lib/python3.10/collections/

Does that look like a reliable ecosystem/software/programming language to you? No.

Granted, there were some fantastic programs like MesonBuild, but even Meson took an extra step avoiding the aforementioned problems, they don't use ANY dependency when building Meson software, they either implement it from scratch or copy the code over to their MesonBuild project. There is also another program in development that may potentially replace MesonBuild altogether in C++ anyway.

All in all, for the love of god, please DO NOT develop with Python, pick anything else, LITERALLY ANYTHING, BUT PYTHON!

Copy link

AkashicSeer commented Aug 16, 2022

Honestly people need to stop using Python to create entire pieces of software to run on anything. Every time I find out that a piece of software I want to use is written in Python the cursing storm begins because I KNOW FOR A FACT it will be an absolute pain in the ass to install and get working and keep it working.
Just why the f*** is Ansible written in python, to fully use it you MUST KNOW PYTHON because you SPRINKLE Python EVERYWHERE. Or if you are like me and know BASH you opt for that 100% of the time over shitty ass Python. Bash always works, python is always a pain in the ass. All over in Ansible docs it tells you to add this and this and that Python package. I hate that shit. My computer is now littered with many versions of Python etc.
Why can't people write software in C/C++ anymore or even Java or Golang or hell why not Rust but anything other than Python. Anything that forces the end user to Dick around trying to install x,y,z is pure HORSESHIT. Python is Dependency hell. But this using Python to develop entire programs shit has become a plague and a scourge to the development world. My blood pressure goes up every time I encounter this horseshit pretend programming language.

Copy link

pglpm commented Aug 16, 2022

It should be called "Pythons", in the plural. And its "versions" should rather be called "forks".

Copy link

AkashicSeer commented Aug 16, 2022

@pglpm LMFAO I wish this page had likes. Dealing with "PYTHONS" is beyond annoying. So many pieces don't work together. When you are reading online tutorials etc. you try the commands and the failure begins. X needs y,z and possible q installed. You need version 2 of b and version 3.5 of c. Then the commands change based on the version too. I write lots of javascript and I hate that shit, but I refuse to write 1 line of a language that changes every minor version and thinks significant indentation is a "Good idea"

Copy link

rilysh commented Sep 16, 2022

Even being an interpreted language, Python is really slow than any other interpreted languages right now we have. Some folks says "speed doesn't matter" yet you also bring frustrated about how slow your program is. It's a horrible idea to use Python for backend, especially a heavy load work, as the concurrency in Python literally suck.

And please, don't conflict with ML and data science where Python is being used. They used it because they wanted to complete a task as soon as possible, there's nothing about speed but all about how easily a concept can be understand by others, same goes to school/college where Python is being taught. I honestly don't think we shouldn't use it, but we should avoid using in critical apps or services where speed, stability and reliability is most important.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment