879 points by gilad 2394 days ago | 957 comments on HN
| Mild positive Editorial · v3.7· 2026-02-28 11:55:17 0
Summary Freedom of Information & Knowledge Sharing Advocates
This ZDNET article is a biographical history of Python's creation and rise to prominence, authored by Nick Heath. While primarily a technology narrative, it implicitly advocates for human rights values—particularly freedom of information and expression through open-source distribution, recognition of individual achievement, and global collaboration. The article celebrates knowledge democratization and the enabling of diverse participation in innovation.
If only its package management were as easy as its syntax...
I wish pip worked the same way as npm: -g flag installs it globally, otherwise it creates a local "python_modules" folder I can delete at any time. And optionally I can save the dependency versioning info to some package.json...
Instead, pip is a nightmarish experience where it fails half the time and I have no idea where anything is being installed to and I'm not sure if I'm supposed to use sudo or not and I'm not sure if I'm supposed to use pip or pip3, etc.
Considering Python can power the largest web sites (Netflix, Instagram), I don’t understand why there’s so much use of much more complicated platform/languages (eg java, .net)?
Note: I am an amateur which is likely the reason for my ignorance.
Python's success is richly deserved. The fact that it has been a long time coming (Python is almost 30 years old!) is an indication of the amount of sheer effort involved, and should give heart for all those working on building up the next generation of languages.
Since this forum is likely to have some folks looking towards the future, I found interesting a couple of talks by Python veteran Armin Ronacher [1, 2]. Watching that presentation makes me wonder whether I should think of this in the context of "Worse is better". That said, Python's runtime introspection is such a killer feature that it's difficult to explain how empowering it feels for someone who is relatively new to programming.
Python has a lot of problems that really slow down development, but they are all fixable.
The biggest issue, in my opinion, is in dependency management. Python has a horrible dependency management system, from top-to-bottom.
Why do I need to make a "virtual environment" to have separate dependencies, and then source it my shell?
Why do I need to manually add version numbers to a file?
Why isn't there any builtin way to automatically define a lock file (currently, most Python projects just don't even specify indirect dependency versions, many Python developers probably don't even realize this is an issue!!!!!)?
Why can't I parallelize dependency installation?
Why isn't there a builtin way to create a redistributable executable with all my dependencies?
Why do I need to have fresh copies of my dependencies, even if they are the same versions, in each virtual environment?
There is so much chaos, I've seen very few projects that actually have reproducible builds. Most people just cross their fingers and hope dependencies don't change, and they just "deal with" the horrible kludge that is a virtual environment.
We need official support for a modern package management system, from the Python org itself. Third party solutions don't cut it, because they just end up being incompatible with each other.
Example: if the Python interpreter knew just a little bit about dependencies, it could pull in the correct version from a global cache - no need to reinstall the same module over and over again, just use the shared copy. Imagine how many CPU cycles would be saved. No more need for special wrapper tools like "tox".
Remember NOT to jump into Python for your new product if don't know Python. If you are developing for a young startup, have time crunch, then stick to what you know.
IF you do not have a language, or know Python a bit, then pick Python. Here are some of the reasons why I stick to Python (young startup/web APIs):
- OOPs is not too strict (might give a headache to some folks)
- Mixins, lambda, decorators, comprehensions - Pythonic ways make me feel productive easily
- Create a data Model, drop into a shell, import and try things
- Can do that on a live server
- Do the same with Controllers, or anything else actually
- really nothing fancy needed
- Command line processing, SSH, OS integration, etc. has so many great libs
- Python Dict someone looks like JSON (this is purely accidental but useful)
- Debugger support even in free IDE like PyCharm Community Ed is great
- Integration to a world of services is so easy, even ones you do not commonly see
- Documentation - many libs have consistent structure and that helps a LOT
- Really large community, perhaps only smaller than Java
- The even larger group of people using Python in all sorts of domains from Biotech to OS scripts
What I would like improved in the language would be an even longer list. Every language has a list like that, but when you are focused on being scrappy and building a product, yet making sure that software quality does not take a big hit, Python helps a lot.
Reading this got me thinking and I wonder if other people feel like me about this, so I'm going to share it. This is not serious, but not entirely unserious...
I try to be a good sport about it, but every time I write python I want to quit software engineering. It makes me angry how little it values my time. It does little for my soured disposition that folks then vehemently lecture me about the hours saved by future barely-trained developers who will ostensibly have to come and work with my code. Every moment working with python (and that infernal pep-8 linter insisting 80 characters is a sensible standard in 2019) increases my burnout by 100x.
I try to remind myself that we're trying to make the industry less exclusive and more welcoming to new developers and "old" isn't necessarily "good" (in fact, probably the opposite), but damn I just don't understand it.
It used to be that I could focus on other languages (Erlang, Nemerle, F#, Haskell, Ocaml, even C++) and sort of balm myself. But now, I can't even overcome the sinking feeling as I read the Julia statistics book that I'm going to be dragged back to Python kicking and screaming in the morning, so why even bother?
And frustratingly: it's one of the few languages with decent linear algebra libraries. And that means it's one of the few languages with good ML and statistics support. So it's very hard not to use it because when you want to cobble together something like a Bayesian model things like PyMC or Edward actually give you performance that's obnoxiously difficult to reproduce.
This is what the industry wants and evidently a lot of people are okay with it, but to me it's misery and I can't work out why people seem to like it so much.
In my opinion, the biggest problem facing Python is still concurrency. The mitigation efforts still look to me like Perl's 'bolted on' implementation of object orientation. Python should have gotten rid of the GIL during the 2 to 3 transition. It may have also been an opportune moment to introduce optional typing and maybe even optional manual memory management, making it useful to develop almost all kinds of software. Write a WASM backend and it could have even been used for front end development.
Python is not eating the world so much as becoming the new Excel. It has a pretty easy learning curve for people who are not programmers. It has pretty good built in tooling. A domain expert, who is not a programmer, can put together pretty impressive models and visualizations relatively quickly.
However, like with Excel, there are serious issues regarding reproducibility, performance, and long term maintenance.
It's so refreshing to not see anyone here whining about Python forcing them to indent their code properly. The kind of people who think that's a PROBLEM instead of a FEATURE really should not be ever writing any new code, and instead should be punished by forcing them to maintain other people's code written with that same lazy misguided attitude, until they recognize how self indulgent, inconsiderate, and disrespectful that is not just to other people who have to read their code, but also to themselves.
The same kind of people criticize Lisp for having too many parenthesis, then go on to write unintelligible shell scripts, Perl and C++ code chock full of skewbald menageries of sigils and punctuation bound together with a towering inferno of precedence rules, terribly worse than Lisp's "too many parenthesis".
According to people who work with a lot of programmes teaching coding, the reason python is so appealing to new coders is the syntax. Particularly the lack of braces, the indents, the nice keywords, that make reading code much easier to a newcomer.
Having taught both python and JavaScript, I can tell you that the former is far far less confusing to newcomers than the latter. Imagine explaining the problem with equality comparison or prototypes in JS to someone who just learnt what an IF statement is.
The reason I agree that python will dominate programming for decades to come is the batteries included and pythonic approach that enables people to do cool things with just a few lines of code. As a result of the above, the ecosystem has reached critical mass. For most tasks there’s a library that does that, and it’s good, and it’s easy to use, and the developer of the library usually doesn’t expect you to understand their opinionated philosophy to use it.
I love the python convention of putting a minimal example on the homepage of a library.
You’re not going to get your average developer to appreciate the beauty of Lisp or the value of static typing. They want their ML to work, or their graphics to display, that’s all. Ends not means, almost entirely, for most people who aren’t full-time programmers.
Let’s not hate on a language that opens up programming to the world, unless we want to be gatekeepers. If you want to maintain an air of superiority, just learn Lisp or Haskell or C++ and write code that’s “deeper” into the tech labyrinth. Programming will probably specialise into “end user programming” and “Service and system programmers”. Embrace the democratisation of coding.
One thing very interesting about Python is how gradual the ride up has been. Perl dominated then sputtered. Java shot up and hit the ceiling. C# is mostly limited to Windows, JavaScript mostly to the web. Ruby stole the spotlight for a few years and then faltered mysteriously. Others found their niche. But Python just keeps chugging along slowly gaining ground almost everywhere like a tortoise to multiple hyped-up hares.
The part that Python really bothers me, as someone who had write Python for almost 10 years, and right now doing it professionally, though personally I don't consider myself a Python developer rather than a Python senior user, is actually obvious to nail down, and frustratingly, difficult to handle.
SLOW. The sin of all. I don't want to make other arguments with people who just come to repeat 'Oh you can make it fast, you are doing it the wrong way'. Sorry, I have heard that 100 times, now is sounds like bug-as-feature excuse to me.
Sorry, but Python is just slow. All the stuff people might bring up is just trying everything to bypass Python itself. Multiprocessing is hell to work with, buggy and unpredictable. Cython is OK but it is not Python.
Python's slowness is like cancer, and terminally so. Down deep, it is because its overtly flexible/loose type system, the never-going-away GIL, and prematurely exposing of C-API makes it almost impossible to optimize without breaking the existing compatibility.
And most importantly, I don't think it is solvable, truth is the patches are so integrated, people already forget what problem they tried to fix in the first place and just live with it.
But it will haunt Python in long term though, people will be struggling with Python in performant production until they start reimagining a world that without Python. Maybe a better Python in that sense.
What stood out to me, reading the comments, is how among the first few comments I read there were 4 comments from people with decades of experience writing python professionally. Each stating their dislike for the language and citing entirely different parts of the language as its biggest problem.
Personally, I'm primarily a C++ programmer with about a decade of professional experience in C++. I also used to do daily work in C# for a few years. For me, python is a language which I use for making simple command line tools, for processing input and clobbering together different tools. I use it to build interfaces which streamline certain workflows. Essentially, I use it as a more powerful replacement for bash or batch. For that purpose, I find that the language works wonders and is quick and easy to work with.
For what it's worth, I have none of the issues the currently top voted comments describe. Dependency hell (apt does that for me), closer to burnout any time I work with it, would rather work with C++ (a language with a completely different purpose)? If the author of the article had written this, people would fall over themselves to say how wrong they are. Nearly everyone who tried Python loves it. From this thread you'd think we're talking about Visual Basic for Applications.
There is a reason Python is one of the most popular languages. PHP was popular because it's quick and dirty, but Python is popular because people love working with it. The arguments in this thread are beyond me. (They're also unsubstantiated, but if I ask for substantiation I'm sure someone can rationalize some reasons to dislike any language, so that's pointless.)
Holy Crap! What a lot of irrational, hyperbolic hate for Python.
I think everybody should spend their first couple of years working in Fortran IV on IBM TSO/ISPF. No dependency management because you had to write everything yourself. Or maybe [edit: early 90's] C or C++ development where dependency management meant getting packages off a Usenet archive, uudecoding and compiling them yourself after tweaking the configure script.
I'm not saying Python is perfect, but if it's causing your burnout/destroying your love of programming/ruining software development you seriously need some perspective.
Am I correct when I assume that most of the people hating on Python here are using it for medium or big projects?
I feel like the dev community figured this out ages ago:
Statically typed languages are easier to read, harder to write, dynamically typed languages are easier to write, harder to read (and also harder to refactor).
For small projects (scripts, prototypes, etc), you don't care about readability, you just want it to be as easy to write as possible. Python really shines here.
For bigger projects, using Python is painful, but that's also the case with pretty much any other dynamic language..
Python 3 comes with it as "python -m venv". Once in the virtualenv, you don't have to worry about the various pip forms and effects, you can just pio install.
You can get fancier than that of course, but that's what works with stock python, on all OS.
2. For each project you want to work on, create a venv. Yes, there are tools for this, but the base venv tool is totally fine. (venv should be included in your Python, but a few distributors like Debian put it in a separate package - install it from them if needed.) Use python3 -m venv ~/some/directory to create a venv. From here on out
3. As a first step, upgrade pip: ~/some/directory/bin/pip install -U pip.
4. Install things with ~/some/directory/bin/pip install.
5. Run Python with ~/some/directory/bin/python.
Slightly advanced move: make a requirements.txt file (you can use .../bin/pip freeze as a starting point) and use .../pip install -r requirements.txt. That way, if you get any sort of package resolution error, you can just delete your venv and make a new one. (Downloads are cached, so this isn't super annoying to do.)
A "project" can either be actual Python development, or just a place to install some Python programs and run them out of the resulting bin/.
(Edit: Yes, I know about activate, see the replies below for why I don't recommend it. With these rules, you get to say "Never ever type pip, only .../bin/pip", which is a good safety measure.)
Java and .NET are no more or less "complicated" than Python or PHP or any other language/stack. The most suitable language for any app/service is what the founding team knows very well.
Difficult problems remain difficult no matter what language you use.
Also, there's a real cost to everything being dynamically typed in large systems. Humans can't keep all the program types in their brain, and having the compiler help you out is kind of a big deal.
I would not use Eve-Online as an example of performance.
Once it gets to a few thousand concurrent users they have to drastically slow down the server tick rate. It's like playing a turn-based strategy game at that point.
Exactly. NPM gets a lot of hate but lockfiles and local install by default is great. The default mode should not be global installation. Also imo virtual environments aren't amazing. Having some mode you have to remember to flip on that changes essentially the semantics of your pip commands seems a little brittle. Tools that work on top of pip and venv like Pipenv or Poetry seem a lot better.
A lot of stuff powered "by Python" is in practice powered by multi-language infrastructures, which can be pretty complex. For example, the Python ecosystem for data science is mostly implemented under the hood in a mix of C, C++, and Fortran, with high-level Python bindings, due to a mixture of legacy reasons and pure Python being too slow. Obviously lots of people still like the end result, but saying this kind of software is in Python is only half the story.
Someone I know made the observation that Python doesn't scale well with code complexity and team size. Statically tyed languages like Java give you a lot of guardrails, and IDEs make it easy to navigate around code, so it's easier for larger teams with larger projects to safely reason about things.
Python's dependency hell is what made me first look at Julia. I develop on Windows (someone has to :) ), and it was just impossible to get all of the numerical libraries like pydstool, scipy, FEniCS, Daedalus, etc. playing nicely together... so I gave Julia a try. And now the only time I have issues getting a package to run are Julia packages which have a Python dependency. Python is a good language, but having everything in one language and binary-free is just a blessing for getting code to run on someone else's computer.
Re. linting, I'd highly recommend Black with whatever line length you want - it'll reliably reformat your code, and once you lose the urge to reformat while typing it's fantastic. It's like deleting a bunch of useless mental code. And the code reviews are even better: include a linting step (ideally with isort) in CI and you can avoid 95% of formatting comments.
- Language design characteristics like static typing and a general lack of support for "magic" can help maintain order in large, long-term, many-contributor codebases.
- The JVM and CLR are both significantly faster and less resource intensive than CPython for a lot of workloads.
- Java and .NET library ecosystems are mature and extensive. Python 2's ecosystem was also mature and extensive, but the community is in the process of throwing it away.
- The real heavy lifting for media transcoding, storage, and serving is certainly not done in Python. Python is acting as orchestration glue for C/C++ programs there, which is a role it does well.
Ruby is a nicer language for general scripting, ie “better bash,” as that’s what it was originally designed for. It’s also a bit faster, and has a vastly better / simpler package management system.
Python does have great scientific / math libraries, and is worth knowing.
One nice thing is the two languages are so similar that it’s pretty easy to switch between them and use whichever fits the bill.
I am about to hit a decade of python experience. I work with it daily, all my major codebases are written in it.
I hate it.
It has an ok object system which is possibly its only redeeming quality. I found Racket about 4 years ago, and any new project that I work on will be in Racket or CL.
I could go on at length about the happy path mentality of python and the apologists who are too ignorant of other people's use cases to acknowledge that maybe there might be some shortcomings.
The syntactic affordances are awful and you can footgun yourself in stupidily simple ways when refactoring code between scopes. Python isn't really one language it is more like 4, one for each scope and type of assignment or argument passing, and all the sytactic sugar just makes it worse.
Not to mention that packaging is still braindead. I actually learned the Gentoo ebuild system because pip was so unspeakably awful the moment you stepped away from the happy path.
Blub blub blub, someone help I'm drowning in mediocrity.
The best, brightest and most informed/experienced people who do not think it is a good idea for significant whitepace to be the determiner of syntactic nesting do not hold that position because they would like to inflict badly formatted code on their maintainers. You've invented a stupendously silly strawman.
I feel the complete opposite. I really enjoy working with python over any other language. R does linear models and time series better and matlab has its charm, but overall I prefer python. Python is so easy to read and quick to program in. I am so glad I am not in the Java/C++ world anymore, but I know people in different roles have to deal with different issues.
There was a time (more than a decade ago) when I wondered if I should learn Perl or Python. Unfortunately I picked Perl, subsequently forgot it and learned Python instead.
I was a Ruby programmer for a long time, but I think the world has moved on. Nowadays, I want a language with some type checking, and Ruby is extremely hostile to any kind of static analysis. Rails was pretty exciting as a replacement for how we built websites in the perl/php era, but now that React has taken over, Rails feels weirdly bloated. I would probably choose Typescript for basically everything now.
Yes, Yes, Yes. I remember when I translated Bitcoin Python code to JavaScript, I was frustrated. Operator overloading is not available in JavaScript. By default JavaScript only supports 32 bit number. You have to use BigInt or use 3rd party library like big-integer. There is no default support for module exponentiation. And many more.
Since most of my professional experience is with C like syntax languages, I don't get how the lack of braces is an advantages, quite the opposite in my limited experience with Python.
Braces define scope unequivocally, they are easy to visually parse and don't care whether you are using tabs or spaces or even if you, loud gasp, mix them. Furthermore, you can copy and paste, say for loop from a method to another method and it will work. In Python you might have to faff about with spaces (I'm sure there must be IDEs that solve this problem but it was no fun on vim or even notepad++)
Article advocates strongly for freedom of information and expression through open-source knowledge distribution. Celebrates Python's release via newsgroup and global dissemination: 'easier to distribute Python without a suitcase full of tapes.' Frames open access as enabling innovation.
FW Ratio: 50%
Observable Facts
Article: 'Van Rossum released Python to the world via the alt.sources newsgroup in 1991, under what was pretty much an open-source licence.'
Text: 'But as the internet revolution gathered steam, it would be much easier to distribute Python without a suitcase full of tapes.'
Page accessible without authentication or payment barriers.
Article includes clear byline and date: 'Written by Nick Heath, ContributorContributor Aug. 6, 2019 at 7:45 a.m. PT'
Inferences
The article positions open-source knowledge distribution as a landmark human achievement, aligning with freedom of information values.
Comparison of distribution methods emphasizes how technology enables information access and expression.
Structural accessibility (free, no paywall) demonstrates alignment with information freedom in practice.
Professional attribution standards support transparency and credible discourse.
Article extensively recognizes van Rossum's personhood, agency, and individual achievement. Biographical narrative, direct quotes, and photo documentation affirm his right to recognition and identity.
FW Ratio: 60%
Observable Facts
Detailed biographical section titled 'Python, the early years' centers van Rossum as individual protagonist.
Multiple direct quotes: 'I basically thought Well, why don't I create my own language...Programming is fun for me.'
Article includes photograph: 'Guido van Rossum at Dropbox headquarters in 2014.'
Inferences
Extensive biographical treatment demonstrates recognition of van Rossum as a person worthy of documented public acknowledgment.
First-person quotes affirm his individual voice and agency in shaping technological innovation.
Article frames open-source intellectual property rights positively. It celebrates Python released 'under what was pretty much an open-source licence, six years before the term was first coined,' treating shared knowledge as an advancement.
FW Ratio: 50%
Observable Facts
Text states: 'Van Rossum released Python to the world via the alt.sources newsgroup in 1991, under what was pretty much an open-source licence, six years before the term was first coined.'
Article contrasts historical distribution barriers with internet-era ease: 'much easier to distribute Python without a suitcase full of tapes.'
Inferences
The article frames open-source licensing as a positive development in property rights, emphasizing freedom to share.
Historical comparison positions open distribution as an improvement over proprietary constraints.
Article celebrates freedom of assembly and association through Python community building. Highlights 'first-ever workshop for the newly-created Python programming language' (1994) and van Rossum's reflection: 'interacting with the fledgling Python community that came into existence. That felt like a big deal.'
FW Ratio: 50%
Observable Facts
Text: 'In late 1994, a select group of programmers from across the US met to discuss their new secret weapon' and 'first-ever workshop for the newly-created Python programming language.'
Van Rossum quoted: 'After we did the first open source release, I built up a rhythm of doing new releases and interacting with the fledgling Python community that came into existence. That felt like a big deal.'
Photo caption: 'Barry Warsaw at the first Python Workshop in 1994.'
Inferences
The article frames assembly of programmers as a significant milestone, indicating positive valuation of collective association.
Van Rossum's characterization of community interaction as 'a big deal' affirms recognition that association enabled success.
The narrative celebrates collaborative self-organization rather than hierarchical control.
Article celebrates meaningful work and choice in employment. Van Rossum: 'Programming is fun for me...I just really enjoyed the idea of starting a big project on my own, of laying out the code I wanted to lay out and designing it the way I wanted.' Frames work as fulfillment and creative choice.
FW Ratio: 40%
Observable Facts
Van Rossum: 'Programming is fun for me. I think that, in part, I just really enjoyed the idea of starting a big project on my own, of laying out the code I wanted to lay out and designing it the way I wanted.'
Text: 'I didn't have a very rich social life at the time. So, instead of just watching TV, I would be coding, or sometimes doing both at the same time.'
Inferences
The article frames programming as intrinsically meaningful and joyful, reflecting positive valuation of chosen work.
Van Rossum's creative agency in designing his own project exemplifies right to choose one's own work.
Narrative positioning of work-as-joy aligns with values of meaningful, fulfilling employment.
Article celebrates global cooperation and international order. Python described as enabling worldwide collaboration: 'Millions of people use Python each day' globally. Highlights international organizations: Netflix (100M+ homes), Instagram, NASA, and collaborative science (black hole imaging).
FW Ratio: 50%
Observable Facts
Text: 'Millions of people use Python each day, with the exponential growth in users showing little sign of tailing off.'
Article: 'Python plays a pivotal role in some of the world's best-known organizations, helping Netflix stream videos to more than 100 million homes worldwide, powering the photo-sharing phenomenon Instagram, and aiding NASA in space exploration.'
Reference to collaborative science: 'It was Python that earlier this year helped stitch together the first images of a black hole some 500 million trillion km away.'
Inferences
The article frames Python as enabling global collaboration and shared scientific achievement across borders.
International scope of usage demonstrates positive valuation of shared technology infrastructure.
Reference to international scientific collaboration implies recognition that global order benefits from shared tools.
Article mentions 'In 2001, the year the Python Software Foundation was established,' implying participatory governance through self-directed community institution.
FW Ratio: 33%
Observable Facts
Photo caption: 'Guido van Rossum in 2001, the year the Python Software Foundation was established.'
Inferences
The establishment of a community-governed foundation represents participation in self-directed institutional governance.
Implicit positive framing suggests alignment with values of participatory governance in open-source models.
Article implicitly supports education through emphasis on Python's accessibility and clarity. 'Professional and amateur developers' use Python, indicating democratized access to knowledge and skills.
FW Ratio: 50%
Observable Facts
Article: 'Python is used for tasks big and small by professional and amateur developers.'
Text emphasizes: 'clear and unambiguous syntax' and 'readability' as features attracting diverse users.
Inferences
The emphasis on accessibility and ease of learning implies positive valuation of tools enabling educational participation.
Broad user base (professional and amateur) reflects democratization of knowledge through accessible design.
Article implicitly celebrates human achievement and individual creative potential through Guido van Rossum's story. The narrative frames personal initiative and innovation as valuable contributions to human progress.
FW Ratio: 50%
Observable Facts
Title frames van Rossum's work as 'side project became the hottest programming language on the planet'—celebrating individual initiative.
Article structure is biographical, elevating a programmer's personal achievement to significant cultural narrative.
Inferences
The narrative arc celebrates individual human potential and creative agency, aligning with preamble's recognition of inherent dignity.
The emphasis on achievement through personal effort reflects implicit affirmation of human worth and capability.
Page provides free public access without paywall. Professional journalism with byline (Nick Heath, Contributor) and publication date supports transparency and credible information distribution.
build 1ad9551+j7zs · deployed 2026-03-02 09:09 UTC · evaluated 2026-03-02 11:31:12 UTC
Support HN HRCB
Each evaluation uses real API credits. HN HRCB runs on donations — no ads, no paywalls.
If you find it useful, please consider helping keep it running.