Does CMake meaningfully support modules yet? From what I can tell, the latest activity on this topic[1] is that it's in an experimental state, and requires that you use a bundled version of ninja[2]. I wouldn't expect CLion to support modules before CMake does.

1: https://gitlab.kitware.com/cmake/cmake/-/issues/18355

2: https://gitlab.kitware.com/cmake/cmake/-/merge_requests/5562

It doesn't matter, they could provide a cmake fork that supports modules

I am a customer, i need module support because we want to embrace C++20 early, i look at what's available and i see Visual Studio supporting modules, the choice is easy to make

Visual Studio has module support since few months already

> and yet they don't even support C++20.. not EVEN MODULES

Can you name a build system that supports them?

Someone made a rule set for bazel: https://github.com/rnburn/rules_cc_module/tree/main/example/...

MSBuild.

And 46% said they will use concepts. I guess people are overestimating a lot or the panel was C++ aficionados.

46% seems way too high. Most C++ programmers just use templates without writing them, so concepts are of no use as the compiler can figure out from the simple types what is wrong with the code and give a good error message. Until you have to write generic code concepts don't have much use, and that seems to be around 10% of C++ programmers.

Unless you mean as in use them to diagnose an error in your use of generic code that you use. Then if you are using a high enough C++ you will use them - though probably without even knowing it.

No, it's the other way around.

Concepts are pretty useless at the moment for error messages, but they're super easy and convenient when you need to disambiguate something like

   void do_it(auto& x) { // x is a vector

   void do_it(auto& x) { // x is nlohmann::json

Just stick a 'requires' in there and it works.

If someone writes:

    auto myFunc(auto& x, auto& y){....}

They're technically using concepts, as auto function params are part of the c++20 concepts stuff.

I don’t use raw C++ anymore, but Rider with Unreal is next level. I primarily use Rider with C# and it’s always up to date with the newest features.

While catching up with what the compilers are capable of, like Windows applications and C++ hot reload.

https://devblogs.microsoft.com/visualstudio/visual-studio-20...

Did they improve build time for C++ in 2022? I’m still on 2019 for my IL2CPP Unity builds and it’s slow because it generates a lot of files. Each generic gets its own file per type.

Il2CPP is slow because C# is a bloated language that doesn't work well with AOT compiler because most of the features people rely on are actually relying on runtime code generation

I mean it takes half the time to build in Xcode on the same machine.

I think you’re also confusing runtime code (dynamics) with reflection. Dynamics rely on reflection. AOT has issues where reflection would be used: generics, serialization, Activator, etc.

No idea about IL2CPP abilities, the C++ code I write isn't tool generated.

Only MSVC has complete C++20 support. GCC and Clang are not all the way there yet.

MSVC claims complete C++20 support, but their concepts implementation is lacking support for requires-expressions. This is a pretty huge oversight, imo.

Depends on the definition of complete: https://old.reddit.com/r/cpp/comments/old0t6/why_does_msvc_b...

I might not have used it in a while, but by experience MSVC features had a tendency to be much more buggier and incomplete than Clang or GCC (mind, new features tend to have bugs everywhere).