Have you even tried modern C++? If no, how can you say that C++98 was peak?

As someone who grew up with modern C++, I can't even imagine going back to C++98 because it feels so incredibly verbose. Just compare how you iterate over a std::map and print its items in C++98 vs C++23:

  // C++98:
  for (std::map<std::string, int>::const_iterator it = m.begin(); it != m.end(); ++it) {
      std::cout << it->first << ": " << it->second << "\n";
  }

  // C++23:
  for (const auto& [key, value] : m) {
      std::print("{}: {}\n", key, value);
  }

  - auto
  - lambda functions and std::function
  - move semantics
  - std::unique_ptr and, to a lesser extent, std::shared_ptr
  - variadic templates
  - std::filesystem
  - std::chrono
  - std::thread, std::mutex, std::atomic, etc.
  - a well-defined memory model for multi-threaded programs
  - unordered containers
  - structured bindings
  - class template argument deducation
  - std::format
  - std::optional
  - std::variant
  - etc.

It's getting ever more complicated and involved. I need both of my hands to count the number of times I've tried coming back to C++ and use its object model for good effect. C++ is fine for simple things, and if you're smart you can scale it a long way (since it contains C).

But when you try to use all these funny features you're enumerating there for something serious, it will invariably end up in an overcomplicated slow compiling morass. Even just trying to make the types click for inserting something into a non-trivial templatized hashmap becomes a tedious act, and the IDE cannot help anymore either.

(Last issue I had was with catching some exception just to ignore it. Turned out catch(std::bad_alloc) doesn't work, you need write catch (std::bad_alloc&).)

I prefer writing simple C-style C++ where I write whole subsystems from scratch, and I can be very clear about the semantics from the start, design in what matters, and leave out what doesn't. Adding all the built-in object semantics baggage is too much overhead.

Moreover, most of the footguns were present in C++98.

Modern C++ is easier and safer than it has ever been.

The biggest slight is simply that there are high quality alternatives.

As someone who grew up with turbo c++ I would also miss pretty much all of these (maybe not variadic template args) but at least boost covers the library parts.