Sources

In the Annual C++ Developer Survey Lite conducted by the C++ Foundation, the community identified a number of major pain points when working with C++. The top five pain points for C++ developers have nothing to do with the language itself, but instead focus on: 1) Managing dependencies. 2) Setting up CI/CD pipelines. 3) Build times. 4) Dealing with CMake. 5) Setting up toolchains and IDEs. With the top C++ pain points being all about the tools, let’s discuss if the language has become more toolable throughout its evolution, what the state of its toolability is today, and how it’s going to change tomorrow.

Um, {ts:98} CMake's super painful for ordinary developers. You all know this. We We all know that CMake is really terrible for {ts:106} ordinary developers. Most people are doing the kind of uh Stack Overflow driven development with {ts:114} CMake. Uh, most people do not actually care about their build system. uh and so you kind of as a regular developer just

In the Annual C++ Developer Survey Lite conducted by the C++ Foundation, the community identified a number of major pain points when working with C++. The top five pain points for C++ developers have nothing to do with the language itself, but instead focus on: … With the top C++ pain points being all about the tools, let’s discuss if the language has become more toolable throughout its evolution, what the state of its toolability is today, and how it’s going to change tomorrow.

distracting, untrustworthy, or ineffective for serious C++ work. Common concerns: Incorrect or subtly flawed code. Wasted time reviewing or correcting AI output. Overreliance leading to skill atrophy. Corpo- rate/security restrictions limiting use. • AI-generated code is often seen as passable only for … • Standardization or libraries that reduce boilerplate could address the most complained-about C++ pain point. • Consider better support in IDEs (e.g., Copilot-style as- ... … [AI-generated summary] Primary Themes (most frequent and emphasized) 1. Standardized Package Management and Build System Problem: Users are overwhelmingly frustrated with in- consistent, complex, and fragmented tooling. Proposed Change: Introduce a standard package manager and build system akin to Rust’s Cargo or Py- … [AI-generated summary] Primary Themes (Most Frequent and Emphasized) 1. Excessive Language Complexity Why it matters: The increasing complexity—both syntac- tic and conceptual—makes C++ harder to learn, teach, and maintain. It discourages newcomers and makes ex- perienced developers feel overwhelmed. … ity features per release cycle. 5. Poor Tooling and Missing Ecosystem Infrastructure Why it matters: The absence of a standard package man- ager, project description format, or build tool makes C++ difficult to adopt in modern development workflows com- pared to Rust (Cargo) or Python (pip). … tals to misleading narratives. 7. Unusable or Overengineered Language Features Why it matters: Features like coroutines, modules, con- cepts, and senders/receivers are often considered too complex, poorly documented, or hard to use in practice. Actionable insight: Design with usability in mind. Require implementation experience and user feedback before standardization. Provide canonical usage examples and training material alongside new features. 8. Failure to Fix Broken or Incomplete Existing Features Why it matters: Contracts, modules, and even core stand- ard library components (e.g., std::vector, std::regex) are seen as broken or half-baked, with no improvement path. Actionable insight: Allocate committee time specifically to reviewing and fixing existing flaws. Consider a "bugfix" release focused on stabilization, not feature expansion.

Common issues like header-include order and link order, which can lead to circular dependencies, are some of such truly delightful aspects. The former is mostly caused by the rather simplistic way that header files are just slapped straight into the source code by the preprocessor. Like in C, the preprocessor simply looks at your `#include "widget/foo.h"` and replaces it with the contents of `foo.h` with absolutely no consideration for side effects and cases of spontaneous combustion. … If you got your code’s architectural issues and header includes sorted out, you’ll find that C++’s linker is just as dumb as that of C. After being handed the compiled object files and looking at the needed symbols, it’ll waddle into the list of libraries, look at each one in order and happily ignore previously seen symbols if they’re needed later. You’ll suffer for this with tools like ldd and readelf as you try to determine whether you are just dense, the linker is dense or both are having buoyancy issues. These points alone are pretty traumatic, but you learn to cope with them like you cope with a gaggle of definitely teething babies a few rows behind you on that transatlantic flight. The worst part is probably that neither C++11 nor subsequent standards have addressed either to any noticeable degree, with a shift from C-style compile units to Ada-like modules probably never going to happen. … ## Fading Love Don’t get me wrong, I still think that C++ is a good programming language at its core, it is just that it has those rough spots and sharp edges that you wish weren’t there. There is also the lack of improvements to some rather fundamental aspects in the STL, such as the unloved C++ string library. Compared to Ada standard library strings, the C++ STL string API is very barebones, with a lot of string manipulation requiring writing the same tedious code over and over as convenience functions are apparently on nobody’s wish list. One good thing that C++11 brought to the STL was multi-tasking support, with threads, mutexes and so on finally natively available. It’s just a shame that its condition variables are plagued by spurious wake-ups and a more complicated syntax than necessary. This gets even worse with the Filesystem library that got added in C++17. Although it’s nice to have more than just basic file I/O in C++ by default, it is based on the library in Boost, which uses a coding style, type encapsulation obsession, and abuse of namespaces that you apparently either love or hate. … Finally, there are some core language changes that I fundamentally disagree with, such as the addition of type inference with the `auto` keyword outside of templates, which is a weakly typed feature. As if it wasn’t bad enough to have the chaos of mixed explicit and implicit type casting, now we fully put our faith into the compiler, pray nobody updates code elsewhere that may cause explosions later on, and remove any type-related cues that could be useful to a developer reading the code.

## Biggest pains of C++ development - Compiler support is lagging behind the standard on certain platforms. - Example: as of July the 3rd, 2024, Apple Clang still doesn’t support std::expected, `std::jthread`(joinable thread), or `std::stop_token`. … - It’s hard/impossible to write C++ modules cross-platform. - Slow compilation of templates. - Poor compiler messages, especially when using templates. C++ concepts help but there they still require a lot of effort to be understood on compilation error. Rust is better at this. - No standard dependency management. - Using Conan or vcpkg is difficult. - CPM package manager is the most promising and least difficult to set up. Check out my tutorial on JUCE with CPM setup. - No standard “recipes” to build 3rd-party libraries; each has custom build. - It’s hard to predict if a third-party library will run on all platforms: Windows, macOS, Linux, Android, and iOS. It’s simply too difficult for most library developers to test. - Third-party libraries warnings are not easy to suppress on all platforms. - Unchecked memory access is very easy to do. - Out-of-range access. - Memory leaks. - Double delete. - Use after delete/move. - Macros are confusing. It’s easy to hurt yourself. - Poor linting. C++ linters often get lost because of transitive inclusion of header files. … - Fortunately, there are libraries that provide the missing pieces like the Boost library or the JUCE C++ framework. - Strings and UTF-8 string handling surprisingly difficult. The library support for UTF-8 emerges just now. - There isn’t a standard way of structuring multithreaded-code. - C++ coroutines are complex to understand and use.

{ts:332} know speaking of which uh it's basically still hard/ impossible to write C++ crossplatform modules nowadays uh modules were introduced in C++ 20 but still crossplatform support is yeah I I don't want to say it's it's {ts:351} limited because it's probably there so I've seen CPP talks uh that CPP con talks and another C++ conference talks exactly on this topic and still I fail uh to use them in in my own project so it seems like way too complicated for a you know average {ts:370} developer I hope this changes soon over time really less hope for the best okay the next big pain point is that if you want to prevent uh this header source file split what you can do of course you can uh Implement everything in headers {ts:390} so you have an header only implementation but the problem is that because headers are included transitively um your B if you change a header file that's used in a lot of places or is very crucial to your application then you basically need to {ts:407} recompile your horr application and uh if use the pimple indium that that helps but if you use templates you need to Define everything in the header files and so this is really slows down development unfortunately then another thing that's related to it {ts:427} if you get something wrong uh especially with templates the compiler messages are not very helpful so with the uh C++ 20 standard the concepts were introduced which uh check you know template uh class template and function plan Arguments for certain preconditions and … {ts:679} change Etc which is a kind of a hassle even if you're you know if you're just starting out in C++ and finally uh if you have a thirdparty library it's hard to predict on which platforms it will run so uh if you would {ts:695} like to support you know Mac OS Windows Linux Android and iOS you really need to do thorough checks to be sure that you know a third party library is supported on all of these platforms because these libraries rarely do such guarantees because of how Dynamic this whole ecosystem is another thing that's {ts:717} painful in relation to third party libraries in C++ is that it's hard to suppress the warnings from those libraries so let's say you want to be you know very accurate you set the highest warning level you set treat warnings as errors in the compiler but then bam you're using some third party {ts:734} library and they don't care about compiler errors or frankly it's may be sometimes difficult to uh stay up to date with the introduced warnings and errors and also the standard changes some some things get deprecated but it's uh often you need to build a huge work around to suppress the warnings on all {ts:755} those third- party libraries and I think the the most difficult setup is that because of some header file inclusions and some Library inclusions some uh file that you don't have control over is being built as part of your library and uh it's very hard to {ts:772} suppress the warnings in in those files what I found is the best way is to Simply set the warnings just for your source files which you're using but it's uh it's very difficult okay Switching gears a little bit another big problem with C++ it is that unchecked memory … {ts:829} a vector for example and you use a subscript operator then it's uh there are no checks performed at the run time so even if you do out of access uh you won't be notified of it and if you come from the Java side there you're accustomed to getting this uh array out {ts:848} of bounds exceptions well that's not the cas in C++ unless you use the specific at member which you should probably most always do and uh this may also be very confusing to people and uh especially it it introduces bugs that are super hard … {ts:997} they're so flexible and Powerful it's very tempting to try to use them but again for newcomers to this language it's something that uh quite difficult to understand and frankly macros are still being used in a lot of places another big pain of C++ that I {ts:1015} found is the poor linting often so lint is a program that analyzes your source files and tries to build this abstract syntax tree and tries to get all the which variable references which number Etc and in C++ because of all these header inclusions the source file get

# Top 8 C++ developer pain points ... … ## 1 – “Let’s grab some coffee…” Slow build and compilation task times This is probably the most common line heard around developers’ desks today. Slow build and compilation times simply mean that the developers have to sit around and drink more coffee, or sacrifice the quality of their work due to *Context Switching*. Slow build times essentially lead to low iteration frequency. C++17/C++20 include some changes aimed to promote productivity, but they don’t always translate to compilation times. ... To make matters worse, there isn’t enough testing being done to the slow iterations and releases. Not only do things become complicated, developers also have a hard time pin-pointing where the issue is, which is already harder to do in C++. A coding error in one area can often cause issues later in the pipeline. This inability to manually locate code issues eventually results in cross-team friction and communication problems between the various stakeholders. … ## 5 – “Your overtime starts now.” Buggy products that require post-release patches/fixes As explained above, ineffective and clumsy development processes lead to buggy products that are often released due to tight deadlines (i.s – new games before the holiday season). Unfortunately, post release work on patches and fixes (extra work for developers) is becoming more and more common across all sectors. ... ## 6 – “What’s going on with the testing results?” Slow feedback cycle from the release and QA teams The ideal scenario for C++ developers is fast iterations with faster testing and results. This helps them launch remediation activities faster for more effective development time, which eventually leads to faster time to market and also enables better planning and design. Unfortunately, this is not always the case. Long build times result in fewer iterations, which either means less testing (compromising on testing coverage with flaky testing practices) or slower time to market (when testing is done properly, but slowly). To make matters worse, unit tests are harder to apply on existing or legacy projects. … |Top 8 C++ Developer Pain Points| |--| |Slow Build and Compilation Task Times| |C++ Language Complexity and Hidden Features| |CI/CD Implementation Hiccups| |Poor Productivity Due to Third-Party Solution Management| |Buggy Products That Require Post-Release Patches/Fixes| |Slow Feedback Cycle from the Release and QA Team| |CloggingMachine Clogging and Hardware Maintenance Issues| |Lackluster Product Design and Poor Planning|

The apps packed with content, processing massive amounts of data or embellished with animations are exceptionally at the risk of long loading time. The irony is, users expect feature- and media-rich applications filled with microinteractions and videos. Raising to this challenge requires taking a closer look at the **main suspects for slowing down the web app:** low-quality code, un-Optimized Databases, Traffic spikes, faulty DNS queries and many more. There’s plenty of solutions on the frontend as well as backend development to deal with them and improve the performance, just to mention lazy loading and server-side rendering. …

### Integration and Compatibility Issues APIs are quite significant in building iPhone applications. ... Some of the challenges in utilizing APIs in iPhone App Development are: #### API Compatibility and Versioning Issues API versions might have different functionalities and syntax. The lines of compatibility differentiating the API version and the app can get bleary especially while dealing with frequent updates and integrating multiple APIs. Hence, developers need to be extra careful in dealing beforehand with API reliability and versioning issues to evade compatibility problems. #### Third-Party Interferences An app relying too much on a third-party service can eventually become highly dependent on the service. It’s functionality can be compromised if an API provider experiences downtime or belays its services. To mitigate such issues, every iOS app developer must account for fallback mechanisms and additional solutions with external reliability. … **2. What are a few performance bottlenecks observed in iOS apps?** Some of the most common bottlenecks contain retarded network requests, inordinate CPU usability, unoptimized UI calibration, as well as a few memory leaks. Such shortcomings can break an iOS app which can prove to be detrimental to the business.

Pain point REST APIs are common. They hide in latency spikes, payload bloat, brittle contracts, and opaque versioning. They turn fast systems into slow ones. Identifying them is the first step to fixing them. Start with response time. Measure end-to-end, not just the backend function. Slow serialization, inefficient queries, and over-fetching data are top offenders. Cut unnecessary fields. Move heavy computation off the critical path or cache results. Next is payload size. Bloated JSON wastes bandwidth. Keep objects lean. Use compression. Reduce nested structures. Minimize joins returned in a single request unless they are required for the client’s next render. Then address version control. REST APIs rot when contracts drift. A breaking change hidden in a minor update causes instant failures downstream. Use explicit versioning in the URL or headers. Lock specs. Document every change. Authentication overhead is another pain point. Repeated handshakes kill speed. Use token reuse, avoid needless redirects, and keep auth logic outside hot paths when possible. Debugging blind is a mistake. Logs must be structured and queryable. Surface status codes, request IDs, and latency metrics per endpoint. Build tracing early instead of bolting it on later. Finally, manage error handling. A vague 500 tells you nothing. Use consistent error formats. Return useful codes and messages. Provide clear retry instructions for clients. A REST API should be readable, testable, and predictable. Every fix is measurable.

If your team suffers from QA and developer pain points, such as excessive Developer Rework, Flaky Tests, Developer wait-time, frequent Context Switching, limited Parallel Testing, and high Infrastructure costs… you’ve come to the right place. … ### 2. Flaky Tests: Flaky tests are automated test failures that break for no apparent reason or change to the code. This frequently occurs due to several different reasons, such as a browser crashing, a device loses connectivity, updates, etc. Many QA Teams waste considerable time re-testing failed scripts or Flaky Failures. When a team is dealing with a large automation test suite, 15%+ of the tests could fail for no real reason. Many teams have policy that requires all automated tests to be passed in order for the build to be released. This leaves QA teams combing through pointless tests for hours which only hurts output and productivity. It’s no surprise that Flaky Tests are frequently the culprit for delayed releases! … ### 3. Developer Downtime: Developer downtime occurs when developers are left waiting for test results from QA. When a developer submits a change to the application via a new commit, he can be left waiting 10 minutes or 10 hours for test results depending on the size and length of the automated tests. This is a major pain point for developers, QA, and software development teams because it holds up productivity and creates a bottleneck of information from testing. Developers can’t continue working on the same task until they get results back, or else they risk making mistakes that they will later have to correct – AKA Rework.