Sources

**Device and Hardware Support Limitations:**Issues highlight hardware-specific limitations such as LayerNorm and BatchNorm failing to compile on Apple M4 GPU with MPS backend, Conv2d being slower on macOS CPUs due to missing MKLDNN backend, and FP8 lowering tests failing on certain NVIDIA devices due to hardware constraints. **Feature Proposals and API Enhancements:**Several proposals aim to improve PyTorch functionality, including adding a debug mode context manager, a new DTensor placement … **Profiler and Debugging Issues:**The PyTorch C++ Profiler fails to collect information for the "privateuseone" backend due to incorrect flag handling, and Inductor pattern matcher improvements are proposed to add debug output and fix error message formatting. **DTensor and Distributed Tensor Bugs:**DTensor has bugs such as torch.equal() failing when comparing scalar to sharded tensors due to incorrect redistribution logic, and a violation in redistribute_cost function where direct redistribution cost is unexpectedly higher than via intermediate states. **Platform and API Inconsistencies:**The C++ Generator API requires platform-specific compilation unlike tensor creation, and importing .pt2 models shows inconsistent input validation between Windows and Linux, causing platform-dependent quantization failures. **Test Failures and CI Issues:**Multiple tests fail or are disabled due to regressions, flaky behavior, or environment changes, including parametrization tests failing after Python 3.14 migration, disabled HFPretrained tests on Linux, and CI failures after PyTorch 3.14.1 release. **CUDA and GPU Backend Problems:**Issues include SIGIOT stack smashing errors in CUDA CI tests indicating memory corruption, hipblaslt MI300 TF32 accuracy problems, and regression in training with Inductor backend causing illegal memory access during backward pass. **Export and Serialization Bugs:**Exporting models with sparse tensor inputs fails due to lack of dynamic shape support, and sequential torch.load() calls on the same stream fail with the new zipfile serialization format, causing errors on the second read. **Torch.compile and Dynamic Behavior Issues:**Using torch.compile with certain features causes errors such as failures with in-place int64 addmm_ operations due to dimension expansion errors, and mixing dynamic Python scalars with 0-d tensors causing excessive recompilations. **Performance and Optimization Requests:**Proposals include adding gating fusion to flex attention epilogue for improved performance, and logging side effects in Dynamo to better track user code behavior. **Backend Compiler and Runtime Errors:**Inductor backend fails compiling models with while loops and scatter ops due to IndexError, and torch._higher_order_ops.while_loop causes CPU-GPU synchronization issues leading to performance degradation. **Documentation and Development Tooling:**Suggestions include adding new Spin CLI commands to simplify development workflows and standardizing OpenReg testing with examples and documentation for new device backends. **Thread Safety and Concurrency Issues:**The non-thread-safe … **Dynamic Shape and Compilation Crashes:**Compiling models with dynamic shapes involving transpose and floating-point scale interpolation crashes due to OverflowError from float infinity to int conversion. **ONNX Export Failures:**Exporting models to ONNX fails with assertion errors when using cdist with dynamic inputs in PyTorch 2.8.0, whereas it worked in earlier versions. **Padding and Autotune Errors:**Padding a dimension marked as dynamic during compilation produces incorrect code and autotune errors despite successful compilation. **Documentation Build and Disk Space Issues:**The CI runner runs out of disk space during Sphinx site builds due to unnecessary rebuilding of already built documentation, suggesting skipping the build to prevent failures. **Numerical Accuracy and Backend Discrepancies:**FFT functions produce incorrect energy normalization on Intel CPUs for specific input sizes, and adaptive max pooling on Apple MPS devices with torch.compile yields significantly incorrect results compared to eager mode. **Segmentation Faults and Integer Overflow:**ReplicationPad2d causes segmentation faults with extremely large padding values near INT64_MAX due to integer overflow instead of raising proper exceptions. … - issues/169313, issues/169643, issues/169756 **Runtime errors with dynamic shapes and data types:**Runtime errors such as a TypeError from applying the unary ~ operator to a 'SymBool' type and a NotImplementedError for the "index_cpu" operation on Float8_e4m3fn tensors highlight challenges with dynamic shapes and new data types in PyTorch. These issues affect model execution and require fixes in later versions or backend support. … - issues/169331 **Graph and compiler correctness bugs:**A bug in the PyTorch compiler causes incorrect ordering of symbolic integer node inputs in the backward graph compared to the forward graph, potentially leading to assertion failures in regional inductor. This discrepancy affects graph correctness despite some cases running without error. - issues/169712 **Side effect detection improvements:**The current method for detecting side effects when using fullgraph=True in vLLM is unreliable, prompting a request for a better approach. Improving this detection is necessary to ensure correct graph compilation and execution. - issues/169598

OUTLINE: 0:00 - Introduction 0:21 - 1. Didn't overfit batch 2:45 - 2. Forgot toggle train/eval 4:47 - 3. Forgot .zero_grad() 6:15 - 4. Softmax when using CrossEntropy 8:09 - 5. Bias term with BatchNorm 9:54 - 6. Using view as permute 12:10 - 7. Incorrect Data Augmentation 14:19 - 8. Not Shuffling Data 15:28 - 9. Not Normalizing Data 17:28 - 10. Not Clipping Gradients

| |**Top 7 Tasks Cited As Pain Points By Aggregate Score **|** (Normalized Score Ranking) **| |--|--|--| |1|Refactor – Rename Item (var, meth, etc.)|2| |2|Refactor – Extract Method (copy/paste)|3| |3|Jump between header and source|4| |4|Refactor – Code Cleanup (copy/paste)|5| |5|Understand compiler outputs (errors/warnings/etc.)|6| |6|Open file/Load project – time to edit|10| |7|Align code to coding style|7| It’s no surprise that every refactoring topic offered in the survey made it to the top of the pain points list. It is well-known that the lack of support for C++ refactoring is widely felt. **AH, BUT WHAT’S THIS?!** Many of you are probably wondering which task made it to the top of the normalized list, and you should! Take a look for yourself: … - *STL errors are seriously convoluted. I had one last week where a modification on line 500 caused an “error” on line 100. And the error was in a different function! * - *My solution takes a long time to load. It can be slow editing large projects. [VS2012] *

It is no secret that managing C++ dependencies is a serious challenge, especially for larger projects. It is consistently cited as a top pain point in ISO C++ developer surveys. The C++ community has been asking for a standard C++ build system and package manager, but we need solutions that we can put into practice today. ... … {ts:174} guess of my findings I want to point out that every year there is an annual survey that gets published uh to isoc cpp.org and this is one of the questions that gets asked which of these do you find frustrating about C++ development there are many response options but I picked the top {ts:193} five so that it doesn't get too complicated on the slide the number one top pain point is managing libraries my application depends on and this has been the case I believe as long as this survey has been conducted in my conversations with large companies I also found that for large … {ts:539} cmake in this case um and I'll go into this a little bit more uh throughout the talk all right so if we switch back to the slides all right so one big challenge {ts:561} with C++ um is that when you compile a binary that B that binary isn't really portable um it's effectively unique compared to some other binary that's compiled in a slightly different way and when you have large companies with many different development teams that are producing individual components that … {ts:596} what compiler and what compiler version are using what is your target Opera system and architecture what are the optional Library features you've turned on for each dependency and in general you have to take a close look at your compiler flags and you have to make sure that every part of that dependency graph is compiled consistently otherwise you have problems with ABI

## Complexity One of the most often criticized points of C++ is its perceived complexity as a language, with the criticism that a large number of non-orthogonal features in practice necessitates restricting code to a subset of C++, thus forfeiting the readability benefits of common style and idioms. As expressed by Joshua Bloch: … I think C++ was pushed well beyond its complexity threshold, and yet there are a lot of people programming it. But what you do is you force people to subset it. So almost every shop that I know of that uses C++ says, "Yes, we're using C++ but we're not doing multiple-implementation inheritance and we're not using operator overloading." There are just a bunch of features that you're not going to use because the complexity of the resulting code is too high. And I don't think it's good when you have to start doing that. You lose this programmer portability where everyone can read everyone else's code, which I think is such a good thing. Donald Knuth (1993, commenting on pre-standardized C++), who said of Edsger Dijkstra that "to think of programming in C++" "would make him physically ill": > The problem that I have with them today is that... C++ is too complicated. At the moment, it's impossible for me to write portable code that I believe would work on lots of different systems, unless I avoid all exotic features. Whenever the C++ language designers had two competing ideas as to how they should solve some problem, they said "OK, we'll do them both". So the language is too baroque for my taste. … In C++26, with the introduction of erroneous behaviour and safety improvements, some of the undefined behaviours are now compile errors such as erroneous behaviour for uninitialized reads, returning a reference for temporary variables, and deleting a pointer to an incomplete type. … C++ stores its classes in header files and they not only expose their public variables and public functions (like C with its structs and function prototypes) but also their private functions. This forces unnecessary recompilation of all source files which include the header file each time these private functions are edited. This problem is magnified where the classes are written as templates, forcing all of their code into the slow header files, which is the case with much of the C++ standard library. Large C++ projects can therefore be relatively slow to compile. … `<iostream>` uses static constructors which causes overhead if included, even if the library is not used. Another source of bad performance is the misuse of `std::endl` instead of `\n` when doing output, as it also calls `.flush()`. C++ `<iostream>` is by default synchronized with `<stdio.h>` which can cause performance problems in command-line I/O intensive applications. Shutting it off can improve performance but forces giving up some ordering guarantees. … One big problem is that iterators often deal with heap allocated data in the C++ containers and become invalid if the data is independently moved by the containers. Functions that change the size of the container often invalidate all iterators pointing to it, creating dangerous cases of undefined behavior. Here is an example where the iterators in the for loop get invalidated because of the `std::string` container changing its size on the heap: … ## Exceptions There have been concerns that the zero-overhead principle is not compatible with exceptions. Most modern implementations have a zero performance overhead when exceptions are enabled but not used, but do have an overhead during exception handling and in binary size due to the need to unwind the call stack. Many compilers support disabling exceptions from the language to save the binary overhead. Exceptions have also been criticized for being unsafe for state-handling. This safety issue has led to the invention of the RAII idiom, which has proven useful beyond making C++ exceptions safe.

**FAQ**: Sure - not perfect, but mature and well-supported, which is good for business. **FQA**: C++ is not “mature” in the sense that different compilers will interpret it differently, and C++ modules built by different vendors will not work with each other. C++ is not “well-supported” in the sense that development tools for C++ lack features and are unreliable compared to other languages. These things make one ask “Am I the first one trying to do this?” all the time. … C++ is different - it’s designed for perfection. Where other languages give you a feature, C++ gives you meta-features. Instead of built-in strings and vectors, it gives you templates. Instead of garbage collection, it gives you smart pointers. This way, you can (theoretically) implement your own “perfect” (most efficient and generic) strings. In practice, this turns into a nightmare since many different kinds of strings, smart pointers, etc., each perfect in its own way, will not work with each other. C++ sacrifices usability for perfection. However, despite the obsession with perfection, C++ is “practical” - from a language designer’s perspective rather than from a user’s point of view. The “practical” thing in C++ is that it’s based on C. This helped the language gain popularity. This is also the main reason for inconsistencies in the language - ambiguities in the grammar (declaration/definition, type name/object name…), duplications of functionality in the different features (pointers/references, constructors/aggregate initialization, macros/constants/templates, files/namespaces…). … Most kinds of built-in language support for object-oriented programming, including no such support, have big advantages over C++ classes. The single biggest problem with C++ classes is that private members are written in header files, so changing them requires recompiling the code using them - for important practical purposes, this makes private members a part of the interface. C++ is built such that recompilation is very slow (an order of magnitude slower than it is with virtually any other language), and classes are built to make recompilation a frequent event. From a business perspective, this means two things: your C++ developers spend a significant amount of their time in recompilation cycles, and C++ interfaces provided to your customers or by your vendors will cause you major headaches (when versions are upgraded, some of the code won’t be recompiled and software will fail in creative ways). Luckily, C++ interfaces are hard to provide (effectively all parties must use the same compiler with the same settings), so quite typically C++ modules have interfaces written in C. … **FQA**: “Generic programming” in the context of C++ refers to templates. Templates are hard to use (and not only define & implement) due to cryptic compiler error messages, extremely long compilation time and remarkable hostility to symbolic debugging - both code browsing and data inspection. The usability problems are not solved by using off-the-shelf components. … Makes it possible for old code to call new code **FQA**: Here are a few more: No practical implementation of C++ runs in managed environments, increasing both the defect rate and the potential damage of an undetected defect Providing C++ interfaces to a software component is impossible in practice due to lack of compile time and run time interoperability C++ is extremely inconsistent and complicated, increasing learning curves and the defect rate C++ compilers typically fail to comply to its intricate standard, reducing portability C++ compilation is both very slow and very frequent, increasing development time and defect rate (people write cryptic and dangerous code to avoid recompilation, for example, use global variables instead of adding arguments to functions, saving 1.5 hours per rebuild x 20 developers = 30 hours of downtime) C++ lacks standard types representing basic data structures like strings, arrays and lists (or has more than one standard and many non-standard ones, which is the same), making it harder to reuse code (each interface works with a different kind of strings) and reducing the speed due to run time type conversion All things mentioned in the FAQ are false for most practical purposes: … C++ doesn’t reduce safety-vs-anything trade-off since it’s extremely unsafe (it “supports” all the undefined behavior of C like buffer overflows, adds many new scenarios with undefined result like invisibility of template specializations at the point of usage, and its complexity reduces the chances that someone actually knows what a program does and can prove its correctness). Where’s the “trade-off”?

### Programming Complexity One of the biggest challenges faced by C++ developers is the inherent complexity of the language itself. C++ is a powerful and flexible language, but it can also be difficult to master. With features like manual memory management and multiple inheritance, developers can quickly become overwhelmed by the sheer complexity of C++ programming. According to a recent survey, 46% of C++ developers cite programming complexity as one of their biggest challenges. This complexity can lead to longer development times, increased debugging efforts, and a higher risk of bugs in the final product. - Feature: Debugging Tools ... C++ is known for its high performance capabilities, but achieving optimal performance can be a challenging task. Developers must carefully manage memory usage, optimize algorithms, and consider platform-specific optimizations to squeeze the most out of their code. According to industry statistics, 54% of C++ developers struggle with performance optimization. This challenge can impact the speed and efficiency of an application, leading to slower execution times and poor user experience. … ### Compatibility and Portability Ensuring compatibility and portability across different platforms and environments is another common challenge for C++ developers. With the wide variety of operating systems, compilers, and hardware configurations available, developers must navigate a complex landscape to deliver a seamless user experience. Industry research shows that 32% of C++ developers struggle with compatibility and portability issues. These challenges can result in platform-specific bugs, deployment difficulties, and increased maintenance costs. … ### Compatibility One of the biggest challenges faced by C++ developers is ensuring compatibility across different platforms and operating systems. C++ code is not always portable, which means that developers may need to make adjustments to their code to ensure it runs smoothly on various systems. This can be a time-consuming process, especially when dealing with legacy code or complex applications. According to a survey conducted by Stack Overflow, 52.6% of developers reported encountering compatibility issues when working with C++. This highlights the importance of writing clean and portable code to avoid potential headaches down the line. ### Memory Management Memory management is another common challenge faced by C++ developers. Unlike higher-level languages like Java or Python, C++ requires manual memory management, which means that developers have to allocate and deallocate memory explicitly. This can lead to memory leaks, segmentation faults, and other memory-related issues if not handled properly. In fact, a recent study found that 42% of C++ developers struggle with memory management, making it one of the top challenges in software development. To address this issue, developers can leverage smart pointers and other memory management techniques to ensure efficient memory usage and prevent memory leaks. … In conclusion, C++ developers face a variety of challenges in software development, ranging from compatibility and memory management to performance optimization and debugging. By understanding these challenges and adopting best practices and tools, developers can overcome these obstacles and create high-quality and efficient applications that meet the demands of today's fast-paced technological landscape. Throughout this article, we have highlighted some of the most common challenges faced by C++ developers and provided insights into how to address them effectively. ... ## The Challenges of Memory Management for C++ Developers ### Memory Leaks One of the biggest challenges for C++ developers is dealing with memory leaks. A memory leak occurs when a program does not release memory that it no longer needs, which can lead to memory exhaustion and performance issues. In C++, memory must be allocated and deallocated manually using functions like new and delete. If a developer forgets to release memory after it is no longer needed, the memory leak can occur. … ### Dangling Pointers Another common challenge for C++ developers is dealing with dangling pointers. A dangling pointer is a pointer that points to a memory location that has been deallocated or is no longer valid. Accessing memory through a dangling pointer can lead to undefined behavior and program crashes. Dangling pointers can occur when a pointer is not updated after the memory it points to is deallocated. … A big challenge for C developers is dealing with pointer arithmetic. It can be confusing at first, but once you get the hang of it, you can do some really cool stuff with pointers. Another common issue is buffer overflows. If you're not careful with your array bounds, you could end up overwriting memory and causing all sorts of havoc. … Answer: Always validate input, sanitize user input to prevent buffer overflows, and use secure coding practices to prevent vulnerabilities. Another challenge is dealing with compatibility issues. C code written for one platform might not work the same on another, so you gotta be aware of differences. Dealing with dynamic memory allocation can be tough.

- Among the three features surveyed (Concepts, Coroutines, and Modules), Modules have the lowest planned adoption rate, only 29.25% of respondents indicated their projects would allow module usage. As the article C++20 modules and Boost: an analysis highlights, concerns exist around managing the potential increase in complexity for build systems. This is likely in addition to modules introducing interoperability challenges between build systems and package managers - a concern that many of respondents are likely to have as usage of multiple build systems was very high - might delay the adoption process until broader tooling support matures. … ### Build times ​ **Encouraging signs for build times!** So much so, it's included twice. Over the past four years, the survey data reveals a consistent downward trend in the percentage of developers reporting long build times as a major pain point. This decrease of 2.38% from 2021 to 2024 suggests that the C++ build ecosystem is becoming more efficient. There's a still a very slim number of developer who are not burdened by long times times. … ### Setting up a continuous integration pipeline from scratch ​ The survey results indicate a persistent challenge. While there's a slight decrease in the percentage of developers reporting it as a major pain point (down to 1% from 2023 to 2024), it remains a significant hurdle for many (nearly a third of respondents!). There's little to no improvement over the 2021 data. … ### Setting up a development environment from scratch ​ The data on setting up development environments reveals a fascinating trend. While there's a positive shift with more respondents finding it a "not significant" pain point (up to 31.93% in 2024), there's also a concerning slight increase in those reporting it as a major pain (26.27% in 2024). One explanation could be advancements in techniques for build script. There are some very high quality sources for CMake. That category saw a in the number of respondents experiencing pain that. However, the challenge of setting up the entire environment, especially for complex systems, seems to be persisting.

There were 16 questions in that category. Respondents were asked to rate the severity of each issue on a scale of: major pain point, minor pain point, or not a significant issue for me. The top 3 reported pain points are: **Managing libraries my application depends on** **Build times** **Setting up a continuous integration pipeline from scratch (automated builds, tests, …)** Just to mention, number 4 on the list is *Managing CMake projects*, which I see as related to the first ones. It is interesting that for C++, notoriously known and criticized by its users as a complex and large language, the major issues seem to be infrastructure ones. There can be reasons for that. ... Let’s look at the top 3 reported pain points in reverse order. ### Nr 3: Setting up a continuous integration pipeline from scratch (automated builds, tests, …) From about 1700 results, 31.35% considered this as major pain, 40.85% as minor pain, and 27.80% as not a significant issue. I am surprised that this topic is rated that high as a pain point. … ### Nr 2: Build times From about 1700 results, 43.34% considered this as major pain, 37.56% as minor pain, and 19.10% as not a significant issue. Build times can indeed be an issue. There are multiple reasons. ... ### Nr 1: Managing libraries my application depends on From about 1700 results, 47.37% considered this as major pain, 35.09% as minor pain, and 17.54% as not a significant issue. Nearly 50% of the respondents consider managing dependencies as a major pain point. That is a lot. Managing dependencies is indeed a problem. Not everyone is Google who can say, ... And for some projects, it can quickly become an expensive mess. So yes, I see managing dependencies in C++ as a major pain point. That was my answer to the survey. And it seems I am not alone in that point of view. … C++, as it is today, may not be able to solve that problem.

6.3. I agree that the rules for operator overloading are somewhat arbitrary, irregular and clumsy (e.g. pre-/postincrement or nothrow-new) 7. Templates syntax 7.1. I'm fine with templates as-is. Yes, I do write metaprograms. No, I would not want an imperative language unless I also get a compile time debugger. … 1. Run time type information 1.1. No real type information except the name 1.2. Non-standardized naming 1.3. No way to selectively disable (or enable) it causing lots of bloat, especially when polymorphism and templates are in the game 2. Lack of C99 features, in particular: 2.1. Variable-length arrays 2.2. Variadic macros 3. Standard library quirks 3.1. STL-iterators and verbose <algorithm> calls 3.2. Missing template 'find' method in std::set 3.3. STL implementations overusing inlining 3.4. STL implementations ignoring allocator type members

The C++ community on Reddit, particularly in the `r/cpp` subreddit, has been buzzing with discussions in September 2025. From modern coding practices to emerging libraries and ongoing debates about language features, the conversations offer a treasure trove of insights for intermediate developers. This article distills the most upvoted content to highlight key trends and techniques, while also addressing controversies and pitfalls raised in downvoted or critical posts. ... Pointer tagging, a technique for packing additional data into unused bits of pointers, garnered significant attention (Score: 189). Users discuss its historical roots and potential pitfalls, noting that while it leverages hardware design (like AMD’s 64-bit ISA), it’s not universally portable. A key concern is verifying whether certain pointer bits are unused on a given system. … ### Data-Oriented Design (DOD) in C++ A keynote from CppCon 2025 on data-oriented design by Vittorio Romeo received enthusiastic feedback (Score: 121). The talk highlights DOD’s benefits for performance in game development and other high-performance domains, with excitement around C++26 reflection features to simplify entity-component-system (ECS) implementations. ... Takeaway: Adopt DOD principles by structuring data for cache efficiency in performance-critical loops, and experiment with libraries like Boost.PFR for reflection-based automation until C++26 features are widely available. … The controversy highlights a broader tension: balancing innovation with stability in a language with a massive, diverse user base. One user notes that C++’s slow, committee-driven process, while frustrating, ensures stability for legacy code (Score: 14). Takeaway: Stay informed about contract features but avoid relying on them in production code until their status is finalized. Use assertions or custom checks as a fallback for now. ### Range-Based For Loops and Lifetime Issues A post about range-based for loops failing with temporary views (Score: 13) reveals a lingering issue in C++20. Users report segmentation faults when iterating over temporary ranges directly, a problem fixed in C++23 but not universally supported across compilers. Community frustration is evident, with advice to bind temporaries to named variables as a workaround. Takeaway: Always bind temporary views to a named variable before using them in a range-based for loop (e.g., `auto view = func(); for (auto& x : view) {}`) to prevent lifetime issues in pre-C++23 codebases. ### RTTI Aversion in the Community Discussions around the Maki library reveal a recurring aversion to Runtime Type Information (RTTI) among some C++ developers (Score: 12 in comments). Reasons include performance overhead, increased binary size (critical in embedded systems), and security concerns like aiding reverse engineering. However, others argue RTTI is useful when needed, advocating for pragmatic use over dogmatic avoidance. … ### Legacy Code and Undefined Behavior A query about memory leaks in a legacy object pool after days of computer uptime (Score: 6) drew critical insights. Community responses suggest undefined behavior (UB) as the likely culprit, exacerbated by compiler upgrades (from g++4 to g++11). Downvoted or neutral comments question the relevance of custom memory management over modern solutions like `std::unique_ptr`. … ## Unpopular Opinions and Downvoted Discussions ### Resistance to Modern C++ Features In downvoted comments on Herb Sutter’s talk (Score: -14), some users argue that prioritizing readable code over performance is detrimental in inner loops, suggesting a fear of replaceability drives obscure coding practices. This contrasts sharply with the community’s push for clarity and maintainability. Similarly, a downvoted response to a C++ interpreter project (Score: -21) dismisses it as nonsense, reflecting skepticism toward experimental or unconventional uses of the language. … 1. **Leverage Modern C++:** Adopt features like `auto`, `std::span`, and range-based constructs to write cleaner, more maintainable code. Watch foundational talks by experts like Herb Sutter to internalize best practices. 2. **Optimize with Caution:** Experiment with techniques like pointer tagging and DOD for performance gains, but validate assumptions (e.g., pointer bit usage) and prioritize portability. … ## Conclusion The C++ community in September 2025 showcases a dynamic blend of enthusiasm for modern practices and caution around stability and legacy challenges. By embracing popular trends like modern styling and DOD, while navigating controversies like contracts and lifetime issues, intermediate developers can stay ahead of the curve.

In the Annual C++ Developer Survey conducted by the C++ Foundation, the community identified a number of major pain points when working with C++. Year-to-year leaders are the same: libraries management, build times, setting a CI pipeline, and project models. Language challenges are also coming to the top regularly, but the lack of tools in the C++ ecosystem is obvious. Let’s see if and how the modern C++ tooling can address the things that frustrate C++ developers the most. We’ll cover things from package management, CI setups, and development environments, to CMake debug and profiling, and a bit of data flow analysis (DFA) to statically identify many sources of undefined behavior and potential vulnerabilities. … {ts:309} evolves whatever the new tools the vendors are bringing to the our tables still tooling is the major issue and you can see many things here like libraries build times project models are in several lines so there are many things so maybe we can improve maybe we