Products · Product
C++
Raised as a usability problem by 496 people on Hacker News over 20 years (2007–2026), in 487 threads.
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 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
Every issue, all time, most people first
Template errors are huge and cryptic to understandUnreviewed
20072026- Using std::variant is awkward and annoying in practice2026-10-13
- Traversing nested std::variant trees for a parse tree is a disaster, worse than tagged unions2026-10-13
- Templates are verbose and complex, and the author keeps making mistakes using them2026-03-30
Cryptic compiler errors leave beginners unable to actUnreviewed
20072026- Compilation errors are unhelpful and the syntax is hard to read2025-12-29
- C++ compiler errors are totally inscrutable and take lots of time to figure out2025-07-03
- C++ error messages were so confusing they made the commenter quit coding2024-12-27
Fancy features make code hard to read and maintainUnreviewed
20072026- Template syntax is verbose and hard to read, barely resembling the rest of C++2026-07-09
- Modern C++ feels dated and annoying; too many ways to do the same thing2025-05-21
- Interacting C++ language features make code meaning hard to understand2024-04-04
Built-in footguns make easy mistakes blow upUnreviewed
20072026- Features must be bent into unintended uses to accomplish basic tasks2026-04-29
- Language has built-in footguns, so developers easily make mistakes that blow up2025-06-05
- Standard features are easy to misuse, causing pitfalls and surprising behavior for programmers2025-02-09
Compiles take so long they slow productivityUnreviewed
20072026- Slow compilation makes the language frustrating to work with2025-12-18
- Compiling takes so long that it badly slows developer productivity2025-11-25
- Compilation is very slow, and private changes force recompiling all dependents2024-03-31
Reading code needs much non-contextual information, slowing workUnreviewed
20072026- Students struggle with unintuitive syntax and inscrutable compiler errors, blocking understanding of core concepts2025-01-13
- Lambda syntax is considered an unreadable horror, adding cognitive load for programmers2022-01-14
- Languages introduced advanced concepts and cryptic syntax too fast, leaving beginner unable to understand what they were typing2021-12-31
Integrating existing libraries into the build is hardUnreviewed
20072026- Building and managing large C++ projects with dependencies is a chore that keeps breaking2025-11-06
- Building C++ software is hard, with no canonical build system and arcane tools2025-09-17
- Setting up builds with C++ modules is broken and painful for developers2024-05-25
Template code needs strange idioms like SFINAE to workUnreviewed
20072026- Template types are tedious to get right and IDE gives no help2025-11-08
- SFINAE and recursive templates are a PITA to write and read2023-07-11
- Must write 'template' keyword before templated member calls on dependent types, tedious2023-02-02
Overloaded operators have unintuitive meanings, hard to readUnreviewed
20072026- Overloaded operators have unintuitive meanings, making code hard to understand2025-09-17
- Overloaded operators like << mean different things, so readers can't tell what code does2021-10-21
- Code becomes hard to read after operator overloading and fancy features2019-05-07
Managing dependencies needs many separate, clumsy toolsUnreviewed
20072026- Package managers can't handle basic popular dependencies, making project setup nearly impossible2025-05-06
- Dependency and artifact management is messy, so too much effort goes into maintaining tooling2022-11-03
- Dependency and package management is a nightmare requiring many separate tools2022-11-02
std::move is widely misunderstood and hard to use safelyUnreviewed
20072026- Std::move is hard to use and leaves moved-from variables usable2021-07-19
- Move semantics feel awkward to use and leave moved-from objects hollowed out2021-07-18
- Std::move doesn't move and leaves source objects in undefined but accessible states2021-04-07
Must remember exact member order to use designated initializersUnreviewed
20072026- Designated initializers must follow struct member order, which is annoying to use2026-06-12
- Designated initializers must be in order and can't be chained, adding syntax noise2026-02-20
- Too many ways to initialize variables; local functions are annoying to define2025-09-06
Easy to pass begin() where end() was meantUnreviewed
20072026- Unintuitive API with weird operator syntax and unexpected invalidation of iterators2026-10-05
- Unintuitive to use; iterators unexpectedly invalidated under load2026-06-15
- Iterator-based design makes code bloated and error-prone compared to ranges2025-06-03
STL behaves unexpectedly and gives obtuse error messagesUnreviewed
20072026- Type errors from STL code produce confusing multipage error messages2025-12-15
- STL too hard to debug, stack traces hard to follow2020-02-27
- STL API is unintuitive to the developer using it2019-05-10
Streams easily left in wrong state; overloaded operators confuseUnreviewed
20072026- Iostream stream-state functions are confusing and verbose, and read() doesn't return a count2024-12-23
- Stream formatting state persists and causes surprising behavior across later output2024-04-01
- Stream API is clunky, unnecessarily stateful, and misuses shift operators2023-12-07
Debugging is slow due to inscrutable behaviour and broken toolingUnreviewed
20072026- Large unfamiliar C++ projects produce cryptic errors and random stack traces, frustrating developers2024-04-13
- Debugging C++ wastes time: inscrutable behaviour, memory safety, broken tooling, platform-specific problems2023-11-22
- C/C++ analysis tools are opt-in, patchwork, painful to configure, and produce false positives2019-11-26
Writing reliable code shifts heavy cognitive load onto programmersUnreviewed
20072026- Writing reliable code takes so much effort that cognitive load shifts to the programmer2021-07-17
- Programmers find the language hostile to use, with trial-and-error wasting time while writing and compiling2021-03-11
- Simple tasks take hundreds of lines of complicated code, too much effort2014-02-16
Setting up a project and build across platforms is tediousUnreviewed
20072026- Can't get a build setup working that they could replicate in their own projects2025-03-13
- Getting started is a pain: project setup, dependency management, and tooling are poor2023-02-15
- Developers must wade through many build tools just to set up a project2017-11-29
Too many new features make the language hard to trackUnreviewed
20072026- Too many new features make the language hard to keep track of2026-03-29
- Endless added features and backward compatibility make the language impossible to learn2023-03-18
- Language has become too complex and hard to learn to an advanced level2022-11-29
Coroutine primitives are complicated and use confusing terminologyUnreviewed
20072026- Coroutines ended up hopelessly complex and confusing despite promises of simplicity2026-11-04
- Low-level primitives make coroutines complicated and terms are used differently than elsewhere2025-07-15
- Coroutines require so much boilerplate that they are hard to use2021-05-22
Similar-looking code behaves differently and fails to compileUnreviewed
20072026- Duplicate, overlapping constructor and assignment rules make the language overly complicated2024-11-09
- Similar-looking constructs behave inconsistently, so code that seems equivalent fails to compile2014-12-09
- Hard to verify which constructor runs; errors show as silent inefficiency, not wrong behavior2014-11-10
Declarations must be split across headers and source filesUnreviewed
20072026- Students struggle to split code between headers and sources and link them in makefiles2026-03-31
- Includes compile only if another header was included first, making errors hard to track2023-10-18
- Header files are a hassle: include order matters, forward declarations and include guards must be written by hand2018-11-15
Installing libraries takes so much effort that trying several is impracticalUnreviewed
20072026- Installing libraries takes great effort, so trying several is impractical2020-10-17
- Importing libraries is a nightmare and the syntax is awkward2020-08-03
- Integrating simple libraries was so hard the author nearly gave up2020-06-25
Build errors are unclear and builds are slowUnreviewed
20072026- Builds take over 30 seconds, so developers lose focus while waiting for error feedback2024-06-28
- Build output is so noisy that warnings are easy to miss or ignored2023-11-30
- Trial-and-error guessing until builds work; feels flaky and painful to use2023-01-20
Combined rules create unintuitive corner cases that are hard to predictUnreviewed
20072026- Even long-time experts struggle to know its rules reliably2017-10-06
- Combined rules produce a combinatorial explosion of complexity and highly unintuitive corner cases2016-11-23
- Defined corner-case rules are dense and counter-intuitive, so even experts get them wrong2010-07-07
Relaxed memory semantics are very hard to reason aboutUnreviewed
20072026- Languages are very hard to use correctly, leading to memory vulnerabilities2024-03-19
- Relaxed memory semantics are extremely hard for programmers to reason about correctly2023-11-05
- Verbose code with many symbols and manual memory management is painful to write2010-12-10
Easy to make mistakes with many ways to go wrongUnreviewed
20072026- Language offers many easy ways to make mistakes, like forgetting the virtual keyword2018-08-05
- Many ways to do each task, unclear which are good, discovered only after mistakes2015-11-13
- Easy to make mistakes and hard to use correctly due to many ways to err2011-08-16
Proposed pointer syntax creates confusing mixed-syntax parsing ambiguityUnreviewed
20072026- Proposed pointer syntax looks no simpler and creates confusing mixed-syntax parsing ambiguity2022-09-18
- Function pointer syntax is abhorrent and hard to get right without practice2020-12-20
- Raw pointers are the default and error-prone; safe smart pointers need ugly extra syntax on every pointer2012-09-28
Getting C++ modules working cleanly is difficultUnreviewed
20072026- C++ modules are a mess, hard to get working cleanly2026-08-19
- Couldn't get modules working, and online guides conflict on how they work2021-08-26
- Modules in C++ are not simple or intuitive to use, and the language is too complex2017-10-11
Can't tell from reading code which calls might throwUnreviewed
20072026- Hard to tell which methods throw, have side effects, or cause undefined behavior2024-06-07
- Developers can't tell by reading code which calls might throw2021-08-13
- Hard to tell which calls throw exceptions and which return errors2018-03-09
Stdin and stdout via iostreams are overly complicated to useUnreviewed
20072026- Iostreams API is atrocious and hard to use2021-11-06
- Stdout and stdin handling via iostreams is overly complicated and frustrating to use2016-03-25
- STL and iostream are awkward to use and limited, forcing reliance on C library2009-05-07
Hard to fix code once it has drifted into a bad stateUnreviewed
20072026- Simple error summaries in other languages give little context about why code fails2022-11-20
- Language has many edge cases and nothing works as the user expects2020-08-13
- Language makes it too hard to fix code once it has strayed2009-05-08
Hard to know which standard library parts to avoidUnreviewed
20072026- Hard to know which standard library parts to avoid; poorly documented2026-08-20
- Shipping a modern standard library on old platforms is hard, forcing developers to become build systems experts2026-06-16
- Standard library is so large it's overwhelming to remember2023-10-14
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
- Coroutines ended up hopelessly complex and confusing despite promises of simplicity2026-11-04
- Too many overlapping ways to do the same thing, hard to keep up with versions2026-10-26
- Using std::variant is awkward and annoying in practice2026-10-13
- Traversing nested std::variant trees for a parse tree is a disaster, worse than tagged unions2026-10-13
- Strict const separation forces awkward constructor-based mutable setup and adds complexity2026-10-05
- Unintuitive API with weird operator syntax and unexpected invalidation of iterators2026-10-05
- Hard to know which standard library parts to avoid; poorly documented2026-08-20
- Each library used incompatible raw-pointer ownership rules, so combining them was complex and error-prone2026-08-19
- C++ modules are a mess, hard to get working cleanly2026-08-19
- Hit many errors getting a simple hello world to build with import std2026-07-25
- Having to write types explicitly everywhere is tedious and poor user experience2026-07-24
- Template syntax is verbose and hard to read, barely resembling the rest of C++2026-07-09
- Intellisense felt unusable and sluggish on large codebases due to single-threaded bottleneck2026-06-26
- Shipping a modern standard library on old platforms is hard, forcing developers to become build systems experts2026-06-16
- Unintuitive to use; iterators unexpectedly invalidated under load2026-06-15
- Accidentally calling the throwing overload gives an unexpected runtime exception for a routine error2026-06-14
- APIs are annoying to use; setdefault-style operations are a chore2026-06-13
- Error messages and symbol names are unreadable, making the code hard to understand2026-06-13
- Designated initializers must follow struct member order, which is annoying to use2026-06-12
- Defaults are wrong and require knowing many hidden pitfalls to use safely2026-06-05
- No bounds checking, so out-of-range access is undefined behavior by default2026-06-05
- Template syntax and ergonomics are hard to work with and maintain2026-05-27
- Templates become boilerplate-heavy and hard to maintain as complexity grows2026-05-27
- Reflection code is so cryptic and confusing that the commenter can only parse it with effort2026-05-13
- Tutorials miss footguns and the standard file reading API is awkward, forcing custom wrappers2026-05-08
- Features must be bent into unintended uses to accomplish basic tasks2026-04-29
- Students struggle to split code between headers and sources and link them in makefiles2026-03-31
- Templates are verbose and complex, and the author keeps making mistakes using them2026-03-30
- Contracts documentation is confusing and the pre() syntax is hard for newcomers to understand2026-03-30
- Too many new features make the language hard to keep track of2026-03-29
- Initialization is the most confusing feature, requiring patterns to remember2026-03-24
- Parameter pack and variadic template syntax is very confusing to read2026-03-15
- Template errors fail deep in nested generic calls, making the actual mistake hard to trace2026-03-11
- Confusing template and operator errors make it hard to locate and fix problems2026-03-10
- Designated initializers must be in order and can't be chained, adding syntax noise2026-02-20
- Cfront on PC was incredibly slow and nearly unusable2026-02-17
- Compiler errors are pages of unreadable output, hard to parse2026-02-08
- Developers can't opt a program out of the distro's library search path; the tooling is terrible2026-01-27
- Compilation errors are unhelpful and the syntax is hard to read2025-12-29
- Slow compilation makes the language frustrating to work with2025-12-18
- Compiler errors list many overloads without saying what actually caused the failure2025-12-15
- Type errors from STL code produce confusing multipage error messages2025-12-15
- Allocators are awkward to use because they are baked into template definitions2025-12-09
- Using std::variant produces huge, unreadable template error messages and awkward ergonomics2025-11-25
- Libraries lack simple CMake rules, so linking them statically is hard2025-11-25
- Compiling takes so long that it badly slows developer productivity2025-11-25
- Template types are tedious to get right and IDE gives no help2025-11-08
- Building and managing large C++ projects with dependencies is a chore that keeps breaking2025-11-06
- Multi-type variants cause confusing compiler error messages and are hard to use2025-10-16
- Std::visit and copy-pasted overload boilerplate are hard to use; error messages are atrocious2025-10-15