Products · Product
Python
Raised as a usability problem by 1,112 people on Hacker News over 19 years (2008–2026), in 1,005 threads.
- 1
- 2
- 3
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
Every issue, all time, most people first
Competing tools and versions make installing packages messyUnreviewed
20082026- Updating Python packages breaks existing code, so each project needs its own VM2026-03-27
- Juggling Python versions, package scopes and virtual environments just to run scripts is annoying2026-03-24
- Libraries require mismatched, unannounced Python and dependency versions, making installs frustrating2026-01-01
Installing packages and setting up venvs is confusing to get workingUnreviewed
20082026- Setting up Python packages on a new Mac requires fiddling with venvs, activation, and PATH hacks2026-10-26
- Venv is prone to breaking projects that depend on system Python2026-09-13
- Too many package managers, venvs break when moved, and installs are opaque2025-12-15
Indentation-based syntax causes bugs that take long to findUnreviewed
20082026- Easy to mess up one indentation level, causing silent logic bugs2026-03-22
- Indentation rules feel finicky and produce head-scratching errors for beginners2024-06-10
- Significant whitespace and tabs versus spaces make the syntax hard to get right2024-02-28
Documentation reads like reference rather than step-by-step instructionsUnreviewed
20082026- Needed Python version only discovered halfway through reading documentation2024-03-25
- Python's official docs are hard to read, so user turns to tutorials2024-02-03
- Official docs read as a reference, hard for new users to follow as a tutorial2023-09-12
Copy-pasted code breaks indentation, requiring manual whitespace checksUnreviewed
20082026- Pasted Python indentation is often broken, forcing manual fixing2026-08-12
- Copy-pasted code breaks indentation, forcing manual whitespace checks and causing hard-to-catch bugs2025-08-17
- Accidentally changing indentation makes editing code feel fragile and frustrating2024-07-08
Nested list comprehensions are too confusing and hard to readUnreviewed
20082026- Dense comprehensions are hard to read and understand at a glance2026-07-26
- Confusing scope, ambiguous ifs, awkward let and tuple parenthesization in list comprehension syntax2025-08-19
- Nested comprehensions are hard to understand; the author repeatedly forgets how they work2025-03-02
Users must guess parameter types without good function documentationUnreviewed
20082026- Can't tell what parameters a function takes, so must read source code2025-09-28
- Spend most time figuring out what arguments functions accept2022-12-30
- Function arguments buried in long paragraphs; list methods hard to locate across pages2022-11-20
Non-technical Windows users struggle to install Python and add it to PATHUnreviewed
20082026- Installing and running Python programs without a shell setup is painful and unpolished2025-05-20
- Typing python opens Store and PATH isn't set, forcing manual alias and PATH fixes2024-03-07
- Python on Windows needs workarounds like Cygwin, and even those often fail2024-01-09
Small language inconsistencies pile up, making it harder to learnUnreviewed
20082026- Inconsistent method names make it unclear which call to use2026-08-21
- Underscore name forms are confusing, and the same forms mean different things by context2026-05-12
- Language has sprawled so much that it is hard to learn without guidance2026-03-10
No package manager understands the virtualenv, causing confusionUnreviewed
20082026- Simple packages take weeks to get working; environments add too much complexity2024-01-09
- Virtual environments and dependencies are easy to mess up without prior knowledge2023-09-15
- Virtual environments are a frustrating stop-gap compared with simpler package handling2023-03-14
Import behaviour mixes many ways and is hard to reason aboutUnreviewed
20082026- Import system is so convoluted that it is hard to follow2023-05-04
- Import behaviour is a confusing mishmash of different ways that is hard to reason about2022-09-28
- Init files make imports behave unexpectedly and are hard to understand2022-08-20
Dependency setup breaks and is hard to fix, even for simple tasksUnreviewed
20082026- Version and dependency conflicts make the language hard to keep working2025-04-28
- Dependencies break and editor config fights distract from solving the actual problem2025-02-01
- Spends about 80% of time getting the dev environment and dependencies right2024-11-08
Basic Python doc searches return junk, outdated answers and dense textUnreviewed
20082026- Searching for basic Python documentation returns junk sites, outdated answers and dense text2025-07-17
- Spent all time searching for help on packages with poor or no documentation2024-09-01
- Finding things in the Python docs is almost impossible; HTML search is useless2023-12-22
Non-ASCII characters cause encoding errors that lose tracebacksUnreviewed
20082026- Non-ASCII characters in text cause encoding errors that lose error tracebacks2023-10-19
- Suddenly getting unicode errors all the time when building international applications2023-10-19
- Platform-specific default encoding bites users silently; must set encoding on every open call2023-07-27
Syntax is too confusing to read and has caused dozens of bugsUnreviewed
20082026- Code is hard to read; mentally parsing where functions and parameters are is taxing2024-07-04
- Line breaks make code harder to navigate and confusing for beginners2024-01-01
- Syntax is awful and very difficult to parse2023-09-11
Too many type annotations clutter code and make it harder to readUnreviewed
20082026- Too many type annotations clutter code and make it harder to read2025-09-28
- Type annotations add so much text that code is harder to read and write, raising error risk2023-03-01
- Type annotations require extra imports in every file and only work well with specific editors2023-02-07
Significant whitespace is confusing for beginners learning to programUnreviewed
20082026- Invisible significant whitespace and missing block delimiters make code hard to read2022-08-14
- Beginners get confused that whitespace affects program behavior and types are hard to grasp2022-04-23
- Significant whitespace is confusing for beginners learning to program2021-11-07
Type hints lack clear docs, stable APIs and an official checkerUnreviewed
20082026- Type hints have a bad out-of-box experience, with unclear docs, shifting APIs, and no official checker2024-12-19
- Type hints feel cumbersome to use in practice, especially coming from TypeScript2024-11-27
- Type hints clutter code and reduce readability for those reading it2023-12-02
Migrating from Python 2 needs painful flag-day changesUnreviewed
20082026- Gets confusing syntax errors for line continuations and must add extra guards for dict access2025-10-30
- Hard to write one codebase compatible with both Python 2 and Python 32023-10-25
- Confusing split between Python 2 and 3 forces teams to support both and confuses new developers2020-02-03
Getting local timezone-aware timestamps is unintuitive and often done wrongUnreviewed
20082026- Makes it too easy to use naive datetimes, which leads to mistakes2023-11-19
- Naive datetime conversions silently assume local time, causing confusing and wrong results2022-10-09
- Time zone functions are inconsistent across versions, poorly documented, and confusing to use2022-10-09
Type-checking tools are slow, hard to use and hard to understandUnreviewed
20082026- Setting up tools is overwhelming and type checkers disagree on what counts as an error2026-07-11
- Typing decorators and file IO is extremely difficult, and type checkers are unhelpful2025-09-28
- Produces many false positive type errors, making it frustrating to use2025-04-29
Setting up and entering a virtualenv takes a clumsy two-step processUnreviewed
20082026- Must set up and enter a virtualenv in a clumsy two-step process2026-06-08
- Virtualenvs can't be checked for cleanliness or undone after mistakes2025-01-22
- Undocumented that activating a virtualenv only changes PATH, which is non-obvious2022-03-04
Tracing argument types in large codebases is hard when debuggingUnreviewed
20082026- Large Python codebases are hard to read due to missing types and flow2026-05-12
- Dynamic typing makes it hard for beginners to track variable types2026-04-18
- Must use a debugger to find variable types at runtime, which is painful2021-11-12
Calling async functions from non-async code is hard for newcomersUnreviewed
20082026- Calling a coroutine then awaiting later doesn't run it concurrently, counterintuitive to developers2025-11-26
- Coroutines, futures and tasks are confusing; APIs demand one or the other for no intuitive reason2025-09-02
- Calling async functions from non-async code is hard, making async hard for newcomers2023-01-16
Finding one function means scanning a huge page of 20+ functionsUnreviewed
20082026- No function index per module, so finding a function means opening the page and using Ctrl+F2021-12-07
- Relevant function docs are buried halfway down a huge page, with no examples or links2019-11-15
- Library docs on one massive page make it hard to tell which function is which2016-04-01
Cryptic error messages make it hard to figure out what went wrongUnreviewed
20082026- Valid-syntax mistakes give no clear error, so finding the bug takes lookup2023-09-07
- Cryptic error messages make it hard to figure out what went wrong2023-05-25
- Error messages say what is wrong but not where the mistake is, making learning hard2022-04-30
Missing conceptual docs and cross-references make asyncio hard to understandUnreviewed
20082026- Base asyncio interface is confusing and overly complex, with hidden pitfalls like task garbage collection2023-02-11
- Basic asyncio examples are hard to get working; the developer struggled to learn it2022-11-10
- Multiline closures are clunky and AsyncIO is complex to grasp2021-03-08
Documentation doesn't say what type functions returnUnreviewed
20082026- Auto-generated docs lack examples, so argument and return types are hard to work out2023-09-13
- Parameter and return types are hard to find, buried in long text2023-07-06
- Developers must dig through code to find each called function's return type2022-08-23
Hard to tell which Python binary or version a system providesUnreviewed
20082026- Hard to tell which python binary or version a system provides2025-04-04
- Hard to figure out which Python runs each tool; must hunt down and install Python 2 manually2023-01-03
- Hard to tell which Python interpreter is used and where packages go2020-06-13
Variable scope confuses beginners, and scope errors only show at runtimeUnreviewed
20082026- Hard to track scope in long nested code, easy to make mistakes2025-09-16
- Loop variables leak into surrounding scope, so you may use the wrong one2025-07-16
- Hard to tell which indentation level or scope a line belongs to in long nested code2023-08-03
Crude type support makes typing Python code a constant struggleUnreviewed
20082026- Hard to read and make sense of type-heavy, generic-filled Python code2025-02-09
- Typing feels like a blindfolded minefield after using a typed language, and Python's subclass-heavy structure makes it worse.2025-01-10
- Type support is so crude that typing Python code becomes a constant struggle2024-02-10
Importing a module by name requires many obscure steps and boilerplateUnreviewed
20082026- Unclear whether a name is a module or attribute, so some import forms break unpredictably2024-07-11
- Importing a module by name requires many obscure steps and boilerplate2022-06-06
- Namespaced imports and manual re-exports are messy and hard to manage2018-12-30
Constant tinkering is required and debugging becomes very hardUnreviewed
20082026- Any code can silently change other code's behaviour, making local reasoning and debugging very hard2021-11-10
- Beginners face an intimidating wall of features and magic when debugging, hard to trace2019-04-19
- Hard to get right, and bugs are horrific to debug when it goes wrong2018-12-01
Pattern matching is unintuitive, requiring knowledge of unpacking stepsUnreviewed
20082026- Official pattern matching docs live in PEPs, hard to find proper usage guidance2025-07-17
- Pattern matching reuses familiar syntax with different meanings, causing mistakes and awkward ergonomics2023-03-21
- Common patterns don't work and need convoluted typing code2022-01-05
Same-directory module files aren't found, causing import errorsUnreviewed
20082026- Can't import modules by relative path; workarounds with PYTHONPATH and importlib break tooling2026-01-07
- Same imports work from one directory and fail from another; must run with -m to succeed2024-10-22
- Importing from a parent directory is unnecessarily difficult and has an inconsistent syntax2024-08-01
The else keyword on loops reads as the opposite of its usual meaningUnreviewed
20082026- The 'else' keyword is confusing; learners don't expect its meaning and find it hard to remember2018-05-28
- The else keyword on loops reads as the opposite of its usual meaning, confusing readers2018-05-28
- Else clause behaves differently than expected, requiring repeated doc reading to understand2018-05-27
Pasting multi-line code into the REPL fails, needing a workaroundUnreviewed
20082026- Early REPL couldn't paste code containing blank lines2026-05-21
- Pasting multi-line code into the REPL does not work well, requiring a workaround2024-05-09
- Pasting code copied from REPL sessions keeps the >>> and ... prompt markers2021-12-30
Published packages never work, and conflicting guidance adds confusionUnreviewed
20082026- Module import and export system feels counterintuitive to the commenter2025-07-22
- Commenter never manages to get published packages working, and finds conflicting guidance confusing2024-03-25
- Commenter has set up projects dozens of times and still doesn't understand it2021-03-08
Metaclasses are hard for most programmers to understand and maintainUnreviewed
20082026- Metaclasses are hard for most programmers to understand and maintain2023-10-27
- Metaclasses make classes behave in unintuitive, hard-to-predict ways2017-05-02
- Developers can't extend a metaclass-based form class and can't tell why2015-02-13
Debug print() with parentheses causes syntax errors, forcing repeated editsUnreviewed
20082026- Confusing error message from a tutorial script, with no hint that print needed parentheses2019-06-07
- Forgets print needs parentheses, so must move cursor to add them while debugging2016-01-02
- Typing print() with parentheses causes syntax errors when debugging, forcing repeated edits2015-04-17
Magic argument inference makes failures hard to diagnoseUnreviewed
20082026- Magic argument names are confusing to reason about and easy to misuse2021-08-07
- Doesn't clearly say what kind of object arguments take, forcing trial and error2020-09-27
- Hard to predict what happens to arguments passed as mutable references2018-12-18
Decorators are barely documented, so learners can't find how to use themUnreviewed
20082026- Decorators adding attributes can't be typed, forcing casts and workaround classes2025-09-28
- Decorators make code unreadable, and hidden bindings make debugging hard2023-06-13
- Decorators are barely documented, so learners can't find or understand how to use them2021-10-10
Setting up a Windows Python REPL takes many error-prone stepsUnreviewed
20082026- Novices struggle to install and manage Python on Windows, and confuse the REPL with the command line2025-12-22
- Default Python REPL is hard to use and poorly designed for console work2024-07-04
- Setting up a Python REPL on Windows takes many steps and is error-prone2023-10-01
Weak regex support and non-trivial file operations hurt scriptingUnreviewed
20082026- Must stop coding and add an import at file top to use regex2025-07-23
- Invalid regex syntax is only discovered at runtime, when the broken line executes2024-10-20
- Python regex requires an import and verbose match-object handling, which is painful2023-04-21
Global package installs make installs messy and conflictingUnreviewed
20082026- Installed packages become system modules, making environments hard to track and keep isolated2025-09-11
- Package system designed as global makes installs messy and conflicting2023-08-02
- Too many options to choose from, and installs can clash with locally installed packages2022-09-08
Standard code silently blocks the event loop and is hard to avoidUnreviewed
20082026- Event loop per-thread and start/stop design is confusing and trips up code2026-08-02
- Standard code silently ends up blocking the event loop, and it's hard to avoid2025-09-02
- Easy to accidentally block the event loop and forget await2020-12-04
Editor re-indenting silently changes program output with no errorUnreviewed
20082026- Moving or adding code requires manual reindenting and double-checking; editor cursor lands at wrong indentation2020-08-25
- Editor re-indenting silently changes program output with no error shown2017-12-09
- Editor can't reindent correctly, forcing manual fixes and hiding invisible whitespace effects2012-01-02
Many overlapping ways to do the same thing confuse usersUnreviewed
20082026- Too many confusing ways to do one simple thing2024-11-04
- Too many overlapping ways to do the same thing, which is confusing2021-03-03
- Multiple ways to do the same thing confuse readers of the code2020-02-26
Building UIs with Qt, WX, GTK or Tkinter is hard and unpleasantUnreviewed
20082026- Python GUI toolkits like Qt, WX, GTK and Tkinter are hard and unpleasant to build UIs with2023-03-14
- Building simple GUI apps in Python feels unintuitive compared to Visual Basic2021-09-21
- Existing Python GUI samples need cumbersome install steps and hoops before use2020-04-25
Typing quit shows a message instead of exiting, requiring quit() or Ctrl-DUnreviewed
20082026- Typing quit shows an unhelpful message instead of exiting the REPL2021-08-02
- Typing quit shows a message instead of exiting, forcing users to type quit() or Ctrl-D2020-12-04
- Typing exit prints a lecture instead of exiting, so the user must learn Ctrl-D2016-01-19
Unclear which metadata file to use, since pyproject.toml lacks setup.cfg contentUnreviewed
20082026- Pip cannot save dependencies to pyproject.toml out of the box, causing constant friction2024-12-14
- Editors like Zed fail to work with tools like asdf, leaving the user unable to set up pyproject.toml2024-10-01
- Pages treat deprecated setup.py approaches as coexisting with pyproject.toml, causing confusion2023-10-31
Tools wreck shell profiles and silently use wrong package versionsUnreviewed
20082026- Tools are slow, have footguns, wreck shell profiles, and silently use wrong package versions2025-08-14
- Environment drift and forced tool upgrades break production and make failures hard to diagnose2023-08-08
- Installing tools easily causes version conflicts that surface as runtime bugs too late2016-08-14
Piping output between processes causes buffering deadlocksUnreviewed
20082026- Running pip repeatedly gives different results; resolution is non-deterministic and must be retried2024-04-03
- Hard to use; piping values between processes makes large dataframes impossible to pass2023-09-14
- Piping output between processes in Python causes buffering deadlocks and easy mistakes2020-10-24
Step debuggers in Python editors are buggy and clumsy beside the REPLUnreviewed
20082026- Python editors' step debuggers are broken, buggy, or cumbersome to use alongside the REPL2021-03-30
- Visual Studio's Python integration feels half-baked and slow to evolve2015-08-04
- Had many problems editing Python code across different IDEs and text editors2011-12-01
Piping commands and conditionals is verbose without third-party librariesUnreviewed
20082026- Python scripts for calling and piping commands become verbose, with glue code dominating the script2023-03-11
- Reading stdin needs boilerplate, and python -c can't take newlines, so it fits poorly in pipelines2019-03-03
- Piping commands and conditionals in Python is painful and verbose without third-party libraries2018-05-14
Explicit self parameter confuses newcomers learning object-oriented programmingUnreviewed
20082026- Explicit self argument confuses newcomers and mismatches call and definition argument lists2014-01-05
- Using self is confusing when defining methods on metaclasses because self is a class object2012-09-08
- Explicit self parameter confuses newbies learning object-oriented programming2008-04-08
Beginners see nothing happen after Enter when brackets are unclosedUnreviewed
20082026- Bracket-and-quote key syntax feels annoying to type and read2015-03-16
- Beginners confused why nothing happens after pressing Enter with unclosed brackets2014-08-09
- Closing parentheses without editor support is frustrating to type2010-04-19
Beginners must absorb confusing, unneeded constructs in their first programUnreviewed
20082026- Languages have sharp corners and historical baggage that confuse beginners learning to program2022-02-09
- Getting a programming environment set up is hard for beginners, blocking them from learning2019-06-07
- Beginners must absorb many confusing, unneeded constructs in the very first program2011-04-30
Bytes and str mismatch makes handling binary data tedious and error-proneUnreviewed
20082026- Every read, write, or print of byte data needs manual encoding and decoding conversions2023-08-14
- Binary data APIs are often unusable when processing bytes in Python 32020-01-13
- Bytes and str incompatibility makes system and binary data handling tedious and error-prone2014-06-29
Reloading changed functions interactively often runs old codeUnreviewed
20082026- Must manually reload and re-run the previous expression after every change2022-11-11
- Interactive reloading of changed functions often doesn't work right, so old code runs2020-11-30
- Testing edited functions requires repeated import and reload commands, unlike the shell workflow2019-04-14
map() returns a generator, so users must wrap list() to get a listUnreviewed
20082026- Must constantly wrap map and filter results in list() calls2020-07-15
- Map() returns a generator, so people must wrap list() around it to get a list2015-06-09
- Map returns iterators, so results aren't shown when run interactively2013-12-30
Zero-based indexing and exclusive slice ends feel unintuitive to learnersUnreviewed
20082026- Slice notation feels counter-intuitive, with an end index that is off by one2023-05-10
- Beginners find 0-based indexing and half-open range() counterintuitive and must be taught around it2021-01-20
- Zero-based indexing and exclusive slice ends feel unintuitive to learners2013-10-24
Iteration options are clumsy, with limited comprehensions and primitive iteratorsUnreviewed
20082026- Iteration has two clumsy options; comprehensions are limited and direct iterators are primitive2017-06-29
- Newbies find iterators and tuple-versus-list differences hard to understand and explain2015-07-31
- Lazy iterators force extra list() calls and nested iterator surprises during exploratory programming2013-12-31
Users gave up on libraries because they couldn't work out usageUnreviewed
20082026- Libraries disagree on style and it is too easy to do the wrong thing2026-08-25
- Poorly designed libraries cause the developer real frustration to use2024-01-27
- Gave up on libraries because the author couldn't work out how to use them2009-12-06
Windows download choices confuse, including Python 2 versus 3 and installer variantsUnreviewed
20082026- Python not installed by Windows Store, and multiple incompatible install choices confuse new users2024-02-08
- Too many confusing download choices on Windows, including Python 2 versus 3 and many installer variants2018-02-17
- Python 2 vs 3 choice link buried at bottom, download page lightly steers users away from 32011-01-22
Wrong-typed inputs are silently reinterpreted, hiding bugsUnreviewed
20082026- Untyped code is hard to navigate and full of type bugs and typos2024-02-18
- Wrong-typed inputs get silently reinterpreted, so bugs are hard to track down2023-02-11
- Type system internals leak into the language, making it hard to understand and work with2020-12-24
Renaming variables is manual and error-prone, with no help finding definitionsUnreviewed
20082026- Renaming a variable silently creates a new one at reassignment, with no error raised2025-10-01
- Renaming variables is manual and error-prone, with no help finding definitions2016-05-28
- Misspelled variable names cause extremely hard-to-find bugs because nothing is declared2010-12-07
Ubuntu ships without working pip or virtualenv, forcing root installsUnreviewed
20082026- Build uses system Python instead of the virtualenv's version, with no clear documentation2023-01-22
- Ubuntu ships without pip or working virtualenv, forcing root installs or compiling Python2018-06-14
- Can't get Python 3 installed via Homebrew, virtualenv and pip working to run scripts2014-01-01
Hard to debug when objects fail to pickle during interprocess communicationUnreviewed
20082026- Processes force pickling objects back and forth, spawn is slow, and fork often fails2025-05-16
- Hard to debug when objects fail to pickle during interprocess communication2023-07-08
- Forced to restructure code around pickling limits when sending work to processes2014-01-27
Autocomplete works poorly on large projects due to missing typesUnreviewed
20082026- Autocomplete works poorly on large Python projects because of missing types2025-10-09
- Autocomplete often does the wrong thing and becomes jarring and annoying due to Python's dynamic nature2024-12-24
- Autocomplete fails in IDEs and red underlines appear everywhere, breaking the development workflow2023-06-05
Hard to get into and hard to read other people's Python codeUnreviewed
20082026- Hard to get into and hard to read other people's Python code2023-08-02
- Commenter finds Python hard to enjoy and says needing an IDE to read it signals design failure2023-03-03
- Python code is unreadable for a blind programmer using screen readers2015-01-29
Overlapping string formatting methods make code hard to readUnreviewed
20082026- Multiple overlapping string formatting methods make learning and reading code hard2025-11-26
- Hard to remember differences between three string formatting styles, switching between them is a headache2025-07-19
- Too many overlapping ways to format strings, so it is unclear which to use2016-02-15
str.join syntax is unintuitive and confusing to newcomersUnreviewed
20082026- String join syntax is counter-intuitive and arguably ugly2011-01-23
- Syntax like str.join is unintuitive, confusing to newcomers, and needs learning to ignore2009-11-16
- Join() is called on the separator string, which confuses newcomers and feels unintuitive2009-07-01
Python error messages are harder to debug than C++ template backtracesUnreviewed
20082026- Error messages are unhelpful, making Python programs hard to debug2025-10-10
- Debugging mixed C++/Python code is painful; can't easily trace data ownership, origin, or types2025-07-16
- Python error messages are harder to debug than C++ template backtraces2022-01-17
Circular imports need awkward workarounds that don't always workUnreviewed
20082026- Forward references need awkward string syntax, and type hints force cyclic imports2025-09-28
- Circular imports force skipping type annotations in many configurations2022-06-27
- Circular imports need awkward workarounds that don't always work2022-04-17
Generics need separate TypeVar declarations, which is awkward to useUnreviewed
20082026- Users must constantly look up many ways to define generic types2023-05-21
- Hard to remember TypeVar scoping and the verbose Generic[T] declaration syntax2021-05-10
- Generics need separate TypeVar declarations, awkward and unintuitive to use2021-01-26
Unreviewed issues were grouped by machine: Claude Haiku labelled each comment as a usability complaint, named what it's about and summed up the problem in a line, and a small model grouped similar problems. Nobody has checked them by hand. Expect mistakes.
The newest 50 complaints
- Setting up Python packages on a new Mac requires fiddling with venvs, activation, and PATH hacks2026-10-26
- Venv is prone to breaking projects that depend on system Python2026-09-13
- Building modern-looking interfaces with Tkinter and ttk is awkward and tricky2026-09-01
- Adding dark mode to a tkinter interface is a giant pain2026-09-01
- Local random.py silently shadows the builtin random module, breaking other tools like black2026-08-31
- Package management is horrible and the community struggles to package code2026-08-25
- Libraries disagree on style and it is too easy to do the wrong thing2026-08-25
- Inconsistent method names make it unclear which call to use2026-08-21
- Pasted Python indentation is often broken, forcing manual fixing2026-08-12
- Event loop per-thread and start/stop design is confusing and trips up code2026-08-02
- Dense comprehensions are hard to read and understand at a glance2026-07-26
- Calling command line tools from Python is cumbersome and verbose2026-07-26
- Slow startup before the program does anything, which is annoying2026-07-16
- Setting up tools is overwhelming and type checkers disagree on what counts as an error2026-07-11
- Function docs lack examples next to definitions, so the user can't tell how to use them2026-07-02
- Python tooling feels like it pigeonholes users into stupid, self-flagellating workarounds2026-06-14
- Must set up and enter a virtualenv in a clumsy two-step process2026-06-08
- Type-checking behaviour is confusing, and basic collection types needed separate imports2026-06-03
- Debugging the PHP-scanning tool was nightmarishly slow because execution in debug mode crawled2026-05-30
- Early REPL couldn't paste code containing blank lines2026-05-21
- Large Python codebases are hard to read due to missing types and flow2026-05-12
- Underscore name forms are confusing, and the same forms mean different things by context2026-05-12
- The py name conflicts with the old launcher, so users get confused about which one runs2026-05-05
- Dynamic typing makes it hard for beginners to track variable types2026-04-18
- Updating Python packages breaks existing code, so each project needs its own VM2026-03-27
- Cancellation counts become awkward when unrelated awaited tasks throw Cancelled2026-03-26
- Juggling Python versions, package scopes and virtual environments just to run scripts is annoying2026-03-24
- Ctrl-U does nothing in the Python shell, so the user keeps trying it and it fails2026-03-22
- Easy to mess up one indentation level, causing silent logic bugs2026-03-22
- Tree traversal in Python is painful, with no easy path to speed it up2026-03-14
- NaN silently gives wrong sort results that slip by unnoticed2026-03-12
- Language has sprawled so much that it is hard to learn without guidance2026-03-10
- Directory spaces break script shebangs, causing hard-to-diagnose failures2026-02-27
- After a pivot, can't tell what column names or types exist, forcing guesswork and debug prints2026-02-04
- Can't import modules by relative path; workarounds with PYTHONPATH and importlib break tooling2026-01-07
- Slide-in donation pop-up pesters visitors and can't be blocked by browser2026-01-01
- Libraries require mismatched, unannounced Python and dependency versions, making installs frustrating2026-01-01
- Couldn't find the right package, so installed an outdated one by mistake2025-12-31
- Creates __pycache__ folders everywhere, cluttering git repos, and the disable setting doesn't take effect2025-12-30
- Calling shell commands needs fiddly subprocess code and ad-hoc streaming loops2025-12-30
- Too many competing tools and ways to set up environments, which makes it confusing2025-12-30
- Libraries have conflicting, unstated Python version and dependency requirements, making installs painful2025-12-30
- Package managers are subtly broken, causing dependency conflicts and days of troubleshooting2025-12-27
- Novices struggle to install and manage Python on Windows, and confuse the REPL with the command line2025-12-22
- Too many package managers, venvs break when moved, and installs are opaque2025-12-15
- Methods aren't discoverable, so the user must look up how to join every time2025-12-08
- Subprocess and pipe syntax in Python is clunky to write2025-12-06
- Python environment and pip tooling is confusing and terrible to work with2025-11-29
- Multiple overlapping string formatting methods make learning and reading code hard2025-11-26
- Packaging is a nightmare to deal with when installing dependencies2025-11-26