From Self Taught to Committee Member’s First Accepted Paper - Waffl3x CppCast 410 / C++Weekly 545

Episode overview

• C++Weekly / CVPcast #410 crossover episode hosted by Jason Turner, with Matu Ro as co-host.
• Guest: Alex “Waffle” (C++ committee member and GCC contributor).
• The conversation blends:
  • C++ language/standards topics
  • toolchain/optimizer concerns
  • C++ safety/security
  • how engineers get into programming

Tech + standardization highlights (key technical concepts / features)

1) Strong types / “strong typedef” and aliasing

• The discussion covers a desire for type safety without heavy wrapper types, i.e., making a type “behave like int but be different from int”.
• Alex describes prior investment in a strong-types/aliases style proposal and why it stalled:
  • Complications arise with implicit conversions—especially when strong aliases interact with:
    • member functions
    • pointers
    • deciding when and how conversions happen
  • Alex is skeptical of “carve-outs” that allow implicit conversions only in some contexts.
• Reflection (C++26) is mentioned as potentially enabling stronger typing patterns, though details remain unclear.

2) C++26 Reflection discussion

• Alex says reflection remains a favorite feature, but it sparked debate early on.
• He highlights “hairy”/edge-case concerns, including:
  • aggregate-related rules (he dislikes/protests aspects of “define aggregates”)
  • two-phase lookup as a major source of complexity
• Despite this, after feedback from reflection practitioners (e.g., Dan Catz is mentioned), Alex believes the feature is “cooked enough” to proceed rather than being pulled.

3) Contracts + assumed semantics / safety angle

• Contracts are discussed as valuable for:
  • static analysis
  • expressing relationships between parameters
• Constraints and limits are debated:
  • Some functional safety arguments can’t be “fully tested” by contracts alone.
  • UB-related concerns come up via contracts and the broader notion of implicit contracts/assumptions.
• The expectation is that compilers will use contract-like information for optimization even if not standardized identically—likely treating contract conditions as assumptions.
• Alex also references work related to refinement types (compiler-side refinement typing ideas).

4) New accepted committee paper: defaulted postfix increment/decrement

• Main feature: defaulting postfix increment (operator++(int)) and decrement (operator--(int)).
• Motivation:
  • For many types, writing both prefix and postfix operators is boilerplate.
  • Postfix typically copies, increments, and returns the copy.
• Benefits:
  • Enables writing operator++(int) / operator--(int) bodies as = default instead of manual code.
  • Reduces risk of subtle bugs (developers no longer have to visually confirm “increment the original vs increment the copy” correctness).
  • Considered beneficial for standard simplification (“takes pages out of the standard”).
• Design constraint:
  • Defaulting is intended to appear on the declaration; out-of-line defaulting/definitions are discouraged, with a “style guide” emphasis.
• Weird/non-default semantics:
  • For iterators where postfix increment/decrement is “weird,” those remain explicit.
  • Most “normal” iterator-like patterns can become defaulted.
• Volatile edge case:
  • They discuss defaulting with volatile.
  • Background includes whether volatile postfix increment/decrement was deprecated/removed in other papers/versions, and a desire not to reopen WG/EWG workflow late in the process.

Other C++ ecosystem / performance / security mentions

5) ULVM: C++ security talks

• Mentions ULVM (LLVM-based workstream).
• Notes that C++ security talks are available on YouTube.

6) Compiler optimization heuristics + PGO concerns

• Optimizer heuristics are described as largely tunable cost models, including:
  • vectorization decisions
  • branch probability handling
• Profile-Guided Optimization (PGO) can hurt if the benchmark/test profile is not representative:
  • optimized for test case
  • worse for real-world workloads
• They briefly speculate that compilers could benefit from more systematic heuristic tuning.

7) JIT as “ultimate” for optimization

• JIT is argued to let runtime values become constants, enabling:
  • stronger inlining
  • branch elimination
  • code specialization based on observed runtime behavior
• They express longer-term interest in integrating JIT ideas into C++, but timelines are uncertain.

Community / process insights

8) How new members get into WG21 / C++ committee

• Alex explains he joined after being encouraged by a friend—after about two years of gradual involvement.
• Sponsorship policy changes are mentioned:
  • contractors are not sponsored anymore unless speaking (as discussed)
• He emphasizes that new contributors can enter even early-career.

9) How papers get written / reviewed

• Alex’s co-author dynamic is described as collaborative:
  • multiple feedback contributors
  • Alex responsible for wording
  • co-author helps “sell” features/justifications
• Matu and Jason note:
  • writing a paper can be a path to contribute
  • they offer to champion papers so authors don’t need to attend solely to argue their case

Key “review/guide/tutorial” elements

• Not a product review or tutorial—primarily an engineering/standards discussion.
• The most tutorial-like content is conceptual:
  • how C++ committee work maps to language features
  • how design constraints (e.g., volatile, reflection edge cases, defaulting rules) influence proposals

Main speakers / sources

• Jason Turner (host)
• Matu Ro (co-host)
• Alex “Waffle” (guest; GCC contributor; WG21 co-author; C++ committee member)