Thread

C++ Insights – See your source code with the eyes of a Compiler

164 points · 35 comments · rramadass

Loading the complete thread in the background. This saved snapshot is available now. Refresh

rramadass · 1790898816 · focus · HN ↗
The tool can be found at - <a href="https://cppinsights.io/" rel="nofollow">https://cppinsights.io/
[deleted] · 1791035720 · focus · HN ↗
[deleted]
StilesCrisis · 1791036041 · focus · HN ↗
I wish the readme example showed a lambda capture. Now that's where compiler magic REALLY shows up.
1. mrlonglong · 1791041447 · focus · HN ↗
  I second this.
  1. rramadass · 1791041944 · focus · HN ↗
    <a href="https://news.ycombinator.com/item?id=49945197">https://news.ycombinator.com/item?id=49945197
    mrlonglong · 1791095926 · focus · HN ↗
    Lambdas are just classes!? Never knew this.
2. rramadass · 1791041838 · focus · HN ↗
  You can see it by typing in some sample code in the tool here - <a href="https://news.ycombinator.com/item?id=49928362">https://news.ycombinator.com/item?id=49928362
3. kccqzy · 1791045419 · focus · HN ↗
  [delayed]
4. WalterBright · 1791048295 · focus · HN ↗
  Lambdas in D are just nested functions:
  int foo(int i) { int add(int x) { return i + x; } // nested function return add(3); } int bar(int i { alias lambda = (x) => x + i; // lambda return lambda(3); } }
5. sltkr · 1791059716 · focus · HN ↗
  C++ lambdas are just structs that overload operator(); once you realize that they become a lot less mysterious. But it's a great example of how this tool is useful to learn about those things (of course you could also read the C++ standard but who has time for that?)
  Here's an example: <a href="https://cppinsights.io/s/f04b6896" rel="nofollow">https://cppinsights.io/s/f04b6896
  1. StilesCrisis · 1791064803 · focus · HN ↗
    I said shows a lambda _capture_. This involves the compiler automatically determining which variables cross the scope boundary, and injecting code for each one.
    frabert · 1791125522 · focus · HN ↗
    I'm curious to understand which part you think is particularly interesting. The compiler clearly knows which variables are declared in what scope, so what's mysterious about figuring out which values need to be captured?
  2. Someone · 1791093439 · focus · HN ↗
    [delayed]
alankarmisra · 1791037689 · focus · HN ↗
Ooo I love these things. I wrote a C++ -> Clang -> JS transpiler so I could show value change states on top of the C++ source code in html and allow people to step through the whole state change. They can also vary the input and see the values change cause the JS layer could recompute the values - which is why I bothered with the transpiling - otherwise I could have just output the state changes and parsed them as CSV for the steps. Fun project!
<a href="https://youtu.be/ZPGysUX62OY" rel="nofollow">https://youtu.be/ZPGysUX62OY
1. ranger_danger · 1791134684 · focus · HN ↗
  This is really cool. Is the source available?
jsrcout · 1791043856 · focus · HN ↗
Definitely trying this out. I've always had the problem of "but what is the compiler thinking?" with C++ in particular.
IshKebab · 1791043914 · focus · HN ↗
This is what let me understand lambdas. Great tool.
1. drysine · 1791054488 · focus · HN ↗
  Good for C++'s coroutines too
  1. pjmlp · 1791055111 · focus · HN ↗
    It also helps to know the .NET model, as C++20 co-routines were inspired by how they work and related magic methods on awaitable types.
f1shy · 1791044519 · focus · HN ↗
I must be the only one who (while I like the tool) feel a little estrange, somewhere between sad, angry, annoyed and disappointed (can’t really express it), that a language needs (or at least is of good use) such a tool.
Like: I wish what is the first interpretation of my code to be obvious. Is not about advanced optimization, or nitty gritty compiler tricks, is about the language. This tool is useful in any C++ compiler. How did we end with such a complex language?
1. rs545837 · 1791045135 · focus · HN ↗
  I don't think it's only C++ though, Python decorators, Rust macros, almost every language's compiler write code you never see. C++ just does more of it and makes it harder to guess. Being able to look at the expanded version is useful in any language that does this.
2. kccqzy · 1791045520 · focus · HN ↗
  [delayed]
  1. f1shy · 1791048172 · focus · HN ↗
    >> needs (or at least is of good use) such a tool.
    drysine · 1791054405 · focus · HN ↗
    >other languages doesn’t need such an explanation tool at all
    Are you sure about that?
    kccqzy · 1791058199 · focus · HN ↗
    [delayed]
3. esikich · 1791046157 · focus · HN ↗
  In what language is compiling simple? Do you not like compiled languages? I'm not sure what you're complaining about here.
  1. f1shy · 1791048067 · focus · HN ↗
    Lisp is simple to compile. Even C (at the level this tool works anyway), also basic, and maybe other 100 languages (again, not the whole compiler, but what this tool shows).
    Compilation per se is not difficult. Doing it with good error recovery, good feedback in case of error, and the optimization is difficult.
    This tool does not tell me those parts (for that is gotbolt) this is about how the first layer of interpretation works, and not for making compilers, but for understanding what the code actually means, because is not obvious at first sight.
    dasyatidprime · 1791054295 · focus · HN ↗
    I agree with an overall thrust of “C++ is overcomplicated and has many moving parts and a lot of implicit stuff happening in the background that makes it difficult to understand”. But I do want to briefly note that Lisp environments have macro expansion steppers for a reason too.
    pjmlp · 1791054709 · focus · HN ↗
    Only if you mean K&R C or the early C89/90 compilers, before the extension explosion, newer language standards, and modern ISAs.
4. rramadass · 1791052469 · focus · HN ↗
  You have misunderstood the language and the tool.
  Compilers for all languages have the concept of "lowering" the level of source-language abstractions from high-level to low-level viz. Written Source -> Simpler Source -> AST -> IR -> Machine Code. One type is "desugaring" i.e. transforming complex syntax to simpler ones so that the following stages of compilation have to operate only on a smaller and hence more manageable language subset.
  This tool shows both desugaring and other lowering (eg. implicit transformations, type deductions etc.) within the C++ source language by regenerating the source from the AST thus giving you full visibility until that stage in the compilation process.
  PS: Explanatory video presentation by the author - <a href="https://www.youtube.com/watch?v=VJ6ZvDRYzNE&t=558s" rel="nofollow">https://www.youtube.com/watch?v=VJ6ZvDRYzNE&t=558s
5. jcelerier · 1791115279 · focus · HN ↗
  Which language do you think doesn't need it? For instance for me I wish I had such a tool whenever I used any interpreted or JIT language, to understand clearly to which semantics whatever is happening maps and how their respective front-end optimizes. Things as simple as "a" + "b" in JavaScript: are you sure you know how every js runtime maps it? Do they fold the strings as an optimization during parsing ? Do they preallocate a larger native string type and push? Do they just do something that ends up an equivalent of std::u16string("a") + std:: u16string("b")?
tweedler290 · 1791050342 · focus · HN ↗
thats crazy. i made this <a href="https://github.com/oooscoos/Benzi" rel="nofollow">https://github.com/oooscoos/Benzi which does the same thing but is language agnostic (supports 9 other languages). urs probs goes in deeper into c++ than mine tho
1. abbefaria27 · 1791053258 · focus · HN ↗
  This is very different and doesn’t relate to what the linked repo does.
kvemkon · 1791061638 · focus · HN ↗
> See your source code ...
What I'd like to see, is how many time is spent to compile each block of C++ code (sliced as fine as possible).
veexx103 · 1791076993 · focus · HN ↗
I’ve worked on something similar, but the code reconstructed from the Clang AST fails to compile due to various issues.
Can these issues be resolved?
kizxc4395 · 1791093669 · focus · HN ↗
This is so interesting
jruohonen · 1791126477 · focus · HN ↗
The online interface was buried somewhere there, but that is pretty nice for educational purposes:
<a href="https://cppinsights.io/" rel="nofollow">https://cppinsights.io/
aktenlage · 1791144905 · focus · HN ↗
Wow, that's awesome. I've been writing C++ since 20 years, and I still stumble over details where I ask myself what exactly is happening. Looking at the machine code is often quite opaque to me, and so is the reference, because it is overly formal. So this will be a great alternative to get a quick understanding of a concrete snippet. Thank you!

Open on Hacker News to reply ↗

Unofficial Hacker News client; not affiliated with Y Combinator.