Hacker News: SuperV1234

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Tue, 10 Mar 2026 18:04:46 +0000

It depends on what you are instantiating and how often you're doing so. Most people write templates in header files and instantiate them repeatedly in many many TUs.

In many cases it's possible to only declare the template in the header, explicitly instantiate it with a bunch of types in a single TU, and just find those definitions via linker.

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Tue, 10 Mar 2026 18:03:18 +0000

Update: I had originally used a Docker image with a version of GCC built with assertions enabled, skewing the results. I am sorry for that.

Modules are actually not that bad with a proper version of GCC. The checking assertions absolutely crippled C++23 module performance in the original run:

Modules (Basic 1 type): from 352.8 ms to 279.5 ms (-73.3 ms) Modules (AoS Original): from 1,077.0 ms to 605.7 ms (-471.3 ms, ~43% faster)

Please check the update article for the new data.

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Tue, 10 Mar 2026 18:02:11 +0000

Please check the article again -- I made a mistake in the original measurements (the Docker image I used had GCC compiled in debug mode) and now the (correct) times are ~50% faster across the board.

Not free, still need to audit, but much better than before. Sorry.

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Tue, 10 Mar 2026 18:01:14 +0000

The data was incorrect due to an oversight on my part (the Docker image I had used compiled GCC with internal assertions enabled).

Including is still very heavy, but not as bad as before (from ~840ms to ~508ms)

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Tue, 10 Mar 2026 18:00:02 +0000

I've updated the article to say "translation unit" the first time "TU" is introduced. The data was also incorrect due to an oversight on my part, and it's now much more accurate and ~50% faster across the board.

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Tue, 10 Mar 2026 17:59:02 +0000

Update & Apology:

I've fully updated the article with new benchmarks.

A reader pointed out that the GCC 16 Docker container I originally used was built with internal compiler assertions enabled, skewing the data and unfairly penalizing GCC.

I've re-measured everything on a proper release build (Fedora 44), and the compile times are ~50% faster across the board.

The article now reflects the accurate numbers, and I've added an appendix showing the exact cost of the debug assertions.

I sincerely apologize for the oversight.

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Tue, 10 Mar 2026 11:15:58 +0000

Nah, many great features are extremely cheap. E.g. constexpr, templates, fold expressions, equality operator defaulting, concepts...

New comment by SuperV1234 in "The hidden compile-time cost of C++26 reflection"

SuperV1234 — Fri, 06 Mar 2026 23:32:38 +0000

I ran some more measurements using import std; with a properly built module that includes reflection.

I first created the module via:

  g++ -std=c++26 -fmodules -freflection -fsearch-include-path -fmodule-only -c bits/std.cc

And then benchmarked with:

  hyperfine "g++ -std=c++26 -fmodules -freflection ./main.cpp"

The only "include" was import std;, nothing else.

These are the results:

- Basic struct reflection: 352.8 ms

- Barry's AoS -> SoA example: 1.077 s

Compare that with PCH:

- Basic struct reflection: 208.7 ms

- Barry's AoS -> SoA example: 1.261 s

So PCH actually wins for just , and modules are not that much better than PCH for the larger example. Very disappointing.

The hidden compile-time cost of C++26 reflection

SuperV1234 — Fri, 06 Mar 2026 17:10:45 +0000

Article URL: https://vittorioromeo.com/index/blog/refl_compiletime.html

Comments URL: https://news.ycombinator.com/item?id=47277865

Points: 60

# Comments: 42

New comment by SuperV1234 in "Problems with C++ exceptions"

SuperV1234 — Wed, 12 Nov 2025 06:57:52 +0000

This post completely misunderstands how to use exceptions and provides "solutions" that are error-prone to a problem that doesn't exist.

And this is coming from someone that dislikes exceptions.

New comment by SuperV1234 in "The Impossible Optimization, and the Metaprogramming to Achieve It"

SuperV1234 — Sat, 01 Nov 2025 11:54:06 +0000

https://github.com/hanickadot/compile-time-regular-expressio...

Building a lightweight ImGui profiler in ~500 lines of C++

SuperV1234 — Fri, 17 Oct 2025 23:51:21 +0000

Article URL: https://vittorioromeo.com/index/blog/sfex_profiler.html

Comments URL: https://news.ycombinator.com/item?id=45623495

Points: 4

# Comments: 0

More Speed and Simplicity: Practical Data-Oriented Design in C++ – CppCon 2025 [video]

SuperV1234 — Fri, 19 Sep 2025 22:44:03 +0000

Article URL: https://www.youtube.com/watch?v=SzjJfKHygaQ

Comments URL: https://news.ycombinator.com/item?id=45307638

Points: 2

# Comments: 0

New comment by SuperV1234 in "The repercussions of missing an Ampersand in C++ and Rust"

SuperV1234 — Tue, 02 Sep 2025 19:18:00 +0000

Note that taking a 'const' by-value parameter is very sensible in some cases, so it is not something that could be detected as a typo by the C++ compiler in general.

New comment by SuperV1234 in "Simplest C++ Callback, from SumatraPDF"

SuperV1234 — Tue, 01 Jul 2025 12:59:28 +0000

This is not proof. What you said is not incorrect, but it doesn't prove that your software is fast because you applied small optimizations everywhere.

New comment by SuperV1234 in "I write type-safe generic data structures in C"

SuperV1234 — Tue, 01 Jul 2025 11:07:10 +0000

Level 4: switching to C++

New comment by SuperV1234 in "Simplest C++ Callback, from SumatraPDF"

SuperV1234 — Tue, 17 Jun 2025 10:40:47 +0000

But do you have actual proof for your first claim? Isn't it possible that the "constant vigilance" is optimizing that ~10% that doesn't really matter in the end?

New comment by SuperV1234 in "Simplest C++ Callback, from SumatraPDF"

SuperV1234 — Mon, 16 Jun 2025 12:15:04 +0000

> Is it because I made hundreds decisions like that? Yes.

Proof needed. Perhaps your overall program is designed to be fast and avoid silly bottlenecks, and these "hundred decisions" didn't really matter at all.

New comment by SuperV1234 in "Learning C3"

SuperV1234 — Tue, 03 Jun 2025 10:50:53 +0000

This is just not true. There's nothing that makes C++ inherently slow to compile.

PImpl doesn't need to have a performance hit as you can implement it with a local fixed-sized buffer that's not heap-allocated.

You can also design your C++ codebase exactly as you would in C, so there's literally no reason why you'll need to recompile more in one language compared to the other.

New comment by SuperV1234 in "Ask HN: Who wants to be hired? (June 2025)"

SuperV1234 — Tue, 03 Jun 2025 10:48:33 +0000

Location: Messina, Italy

Remote: Yes

Willing to relocate: No

Technologies: Modern C++ (C++11/14/17/20/23), and the usual hodgepodge of languages/tools every senior engineer has encountered in ~15 years of real world projects

Résumé/CV: https://romeo.training

Email: mail (at) vittorioromeo.com

---

Hello!

I'm Vittorio, a passionate C++ expert with over a decade of professional and personal experience. My expertise covers library development, high-performance financial backends, game development, open-source contributions, and active participation in ISO C++ standardization.

As the coauthor of "Embracing Modern C++ Safely" and a speaker at over 25 international conferences, I bring real-world insights to empower you fully utilize C++ to its advantage.

I offer specialized training, mentoring, and consulting services to help companies & individuals leverage the full potential of C++.

I am also open to fully remote C++ development/teaching positions.