I spend a lot of time in C++, so I try to evaluate language features by one standard: do they improve correctness, clarity, or performance in code that I would actually ship?

That filters out a lot of hype.

Features I value most in day-to-day work

std::span

std::span is one of the cleanest examples of modern C++ being genuinely useful. It makes APIs easier to read, avoids unnecessary copies, and gives me a better vocabulary for contiguous views over memory.

std::expected

I like std::expected because it makes failure an explicit part of the interface. In systems code, that matters. It helps keep error handling local and understandable instead of burying it behind conventions.

Ranges, selectively

I use ranges where they improve readability without obscuring cost. That distinction matters. Elegant code that hides allocations, iterator invalidation, or unnecessary traversal is not an upgrade.

constexpr and compile-time validation

Where compile-time evaluation can remove ambiguity or enforce invariants, I want it. This is especially valuable in configuration-heavy code, parsers, and fixed-format protocols.

What I still optimize manually

No language feature removes the need to care about the basics:

  • memory layout
  • allocation patterns
  • branching behavior
  • cache locality
  • copy boundaries

That is one reason I still enjoy working in C++. It gives me enough control to make performance visible and actionable.

The workflow that matters more than syntax

My useful C++ workflow is built less around shiny syntax and more around discipline:

  • profile before assuming
  • keep interfaces narrow
  • separate hot paths from orchestration logic
  • prefer simple ownership rules
  • make instrumentation cheap enough to leave in place

This is where many projects improve fastest. Not by using every new feature, but by adopting a clearer engineering style.

Current areas I am watching

These are the areas I am paying the most attention to right now:

  • executors and concurrency direction
  • better error modeling
  • practical coroutine use in real systems
  • data-oriented design patterns that still feel maintainable
  • tooling improvements for profiling and diagnostics

The best C++ code I see is not trying to prove cleverness. It is trying to make hard systems problems tractable.

That remains the reason I keep coming back to the language.