Björkus "No time_t to Die" DorkusApr 6

A r e y o u r e a d y t o h a v e s o m e f u n ?

:3

Show threadBjörkus "No time_t to Die" DorkusApr 6

"This is going to destroy my build system"

Nope! It's able to determine everything that will be processed by the Phase 7 compile-time-computed strings by Phase 4, and presents all of that information through already-available means, meaning CMake/build2/meson/make/ninja/etc. can all understand the dependency chain here natively!

Show threadBjörkus "No time_t to Die" DorkusApr 6

Ultimately, this means we can process files -- recursively -- at compile-time, meaning that rather than embedded shaders with #​includes that can't be touched, we can process those includes and make true single blobs without extra build steps.

compile-time python with imports is VERY possible.

Show threadMartin UeckerApr 6
@thephd Cool, but why?
Show threadBjörkus "No time_t to Die" DorkusApr 6

@uecker C++ has capabilities that can make great use of this. A perfect example is using (Generative) reflection to generate, at compile-time, the perfect FFI that maps to Python, or Lua, or JavaScript, with all of the utility that comes from having it mapped perfectly to C(++) interfaces and fully type-checked while always being generated directly from said Lua or Python or JavaScript source code.

This also applies to things like e.g. Rust and C++ interop, which has also been the topic of discussion and monetary investment. (Not that they're paying me; I wish they would, I could do a lot more for them than just std::embed.)

C doesn't have the systems in place to do things like this, so in most cases they'd just have to rely on the usual techniques used today: code generators, hand-written parsers, fresh data files and description files used to drive code generation (like e.g. SWIG). Certainly not bad, but not nearly as "automated luxury FFI" as C++ can make it.

Show threadMartin UeckerApr 6
@thephd What I do not understand is why the extra build step is a problem.
Show threadmanxApr 6
@uecker @thephd https://mastodon.online/@manx/116261044523322289
Show threadmanxApr 6
@uecker @thephd This exact extra backwards cyclic dependency is probably the single most significant reason why building C and C++ code is hard.
Show threadMartin UeckerApr 6
@manx @thephd Can you explain what you mean? I do not generally find building C code hard - not even when it runs code (which it rarely does).
Show threadmanx

@uecker @thephd
make
ninja
cmake
msbuild
premake5
autotools
vcpkg
conan
apt
yum
rpm
...

Having a reverse dependency on the build system multiplies this nonsense, especially when cross-compiling and interacting between different build systems.

Compare this to any (really any) other language.

This is really not fixable if every build system invents its own mechanism for generating code at build time, thereby locking any project into build system vendor specific mechanisms.

Apr 6 at 7:51amWeb
Show threadMartin UeckerApr 6
@manx I agree that the lack of standardization of build systems is a problem.
Show threadMartin UeckerApr 6
@manx But I think it partially also reflects the size of the ecosystem. I really do not like many other languages that provide a framework that locks you into a specific way of doing things.
Show threadmanxApr 6

@uecker @thephd If you are cross-compiling, you are running the interpreter and code generator on the build host instead of on the build target, which means, if it requires any platform-specific knowledge (like the size and alignment of fundamental types), you have to manually duplicate this knowledge into your custom interpreter.

Inside the target language itself, this information is naturally trivially available.

Show threadMartin UeckerApr 6
@manx @thephd Cross-compilation is a good argument, but it is still not clear to me that this would not be better solved at a different level.
Show threadmanxApr 6
@uecker @thephd I am also not 100% sure that doing this in constexpr context is necessarily the best approach (mainly because debugging constexpr code is a completely unsolved problem), but it is frankly the best approach I have seen offered so far, and IMHO far better than involving the build system in any way.
Show threadMartin UeckerApr 6
@manx @thephd IMHO if people are unhappy about build systems (which seems to be the case and there are certainly good reasons), one should think hard why this is the case and fix it at that level. This is hard, because it is likely not just a technical issue, but lack of standardization and the need to support annoying environments that intentionally wanted to be different.
Show threadmanxApr 6
@uecker @thephd I agree, and I think reducing the scope and responsibility of what build systems need to do, is a good and necessary step into that direction.