Which will probably be never.
I mean, all cmake does is run some commands for you. You not understanding cmake errors (mostly) means you don't understand the errors given to you by the C/C++ compiler.
Partly, yes. But I also think their documentation is a bit hard do read. Maybe this will get better with time.
I use rust btw.
I use distcc, and do not have to take vacation for my programs to finish compiling.
If it means my code won't panic out of nowhere and cause a disaster for me, I am willing to "take a vacation" for my program to finish compiling.
Maybe this will get better with time.
Yes, just give it a few more decades.
CMake can also emit its own errors during the configure step though, particularly if you have complicated build logic and/or lots of external packages.
Did you know that there is a debugger in Jetbrains CLion (and I think VS as well) that allows you to step through your CMake scripts? As ridiculous as this may seem, actually it is really useful.
Even in VS? Nice, gonna check that out.
Life is and will always be better writing your own Makefiles. It's literally so easy. I do not get the distaste. Cmake is arcane magic. Bazel is practically written in runes. Makefile is a just a glorified build script, but where you don't have to use a bunch of if statements to avoid building everything each time.
really anyone worth their salt should write perl code to generate makefiles depending on the phase of the moon and if you sacrificed a $chicken, a @chicken, or a %chicken at runtime.
It's one of those massively elegant concepts of the past that's become unfashionable to learn pretty much just do to time and ubiquity.
That works until you need to support Visual Studio or Xcode. Then you either maintain their stuff manually too, or you get CMake to generate all three. I don’t love it but it solves the problem it’s meant to solve. The issue is people using it when they don’t need to.
Xcode implies MacOS, you can use make there too, just beware that some commandline tools take different arguments on BSDs.
I'm not familiar with either why can't you use Make with VS or Xcode? Can you not set them up to have whatever build bind call Make ?
Manual makefiles don't scale though and you end up needing some other bootstrap framework pretty quick.
this is fine until you need autotools which is worse than cmake
Grab a brush and put a little cmakeup.
Thanks for the laugh.
That was also my experience, but it ended when I stopped using cmake.
I'm not mad at anyone for using cmake, but I consider myself blessed on each day that I don't have to collaborate with them (on cmake).
Which is weird, because someone will have to pry a Makefile from my cold dead hands, someday.
The C in Cmake maybe stands for cat. It would make sense.
In case anyone wants to know the actual answer, it stands for cross platform make, and my understanding is that it’s for generating build project files for various development environments. For instance, with one CMake file you can generate a Visual Studio Solution file, an XCode project file, a Makefile, etc. Several IDEs are also able to read CMake files directly.
I like this idea!
Professional CMake: A Practical Guide by Craig Scott is an excellent guide to modern cmake usage. Well worth the $30 if you need to build, maintain, or modify a CMake project.
Thanks a lot!
And an update has just been released today!
This was solved by moving to bazel. It's a bit more verbose and resource heavy, but the language is sane and how you structure your build code makes a lot of sense
Based on this comment*, I'll migrate a large project to bazel now. I'll report how it goes.
Good luck, from my experience with bazel it may go smooth if you have someone who can into bazel to help you, and you create the project from scratch to then maintain small changes. Then there was my attempt to migrate an existing Java project to bazel without external help that failed hard (maybe the situation improved from 2021).
Not sure about java, but I migrated a fairly big c++ project knowing only the basics of Bazel. Disclaimer: I know the codebase extremely well and we don't have any third party dependencies and the code is c++ and some python generators, validators, etc (which fits the bill for Bazel perfectly)
What I found super hard were toolchains. It's very verbose to define a toolchain
I have legitimately never met a single person in real life who has anything positive to say about bazel, and I assume it it because they have all killed themselves.
There are cmake debuggers where you can walk through exactly what it's doing line by line
Do you have a good one which you can recommend?
cmake debugger
I use this one in vscodium https://open-vsx.org/vscode/item?itemName=ms-vscode.cmake-tools
Who debugs the builds of the build debugger?
Someone with only a tenuous grip on their sanity, I'd imagine.
I’m in this photo and I don’t like it
sudo make me a cmake
I never finished reading my CMake book that weights about two kilos. It's now outdated, except for the core concepts.
I forgot to assign a variable, now it crashes %5 of the time. It's wild how c doesn't default variables to null or something.
default variables to null or something
That is such a bad idea. Better to have the compiler warn you about it like in Rust, or have the linter / IDE highlight it.
C does exactly what you tell it, no more. Why waste cycles setting a variable to a zero state when a correct program will set it to whatever initial state it expects? It is not user friendly, but it is performant.
Except that this is wrong. C is free to do all kinds of things you didn't ask it to, and will often initialize your variables without you writing it.
It wouldn't be that much processing compared to the rest of the app. It would lot more efficient than running an effectively infinite loop or arithmetic on an arbitrarily large number as a result of an unsigned variables.
That's like one thing ML can actually help with XD cute cat
Imo just use something else. If your build system is really simple just write the Makefiles yourself. If the build system tho needs to be really complex I would use something like meson or scons (Having worked on some gigantic fully GNU make build systems it can get pretty out of hand).
This is all a personal preference thing but cmake in my experience is really non intuitive and a pain to debug. I know it works for a lot of people but I definitely prefer particularly like scons since its python I have a bit easier time understanding what's happening.
If you really need to use cmake, use a debugger like another user commented. There's also a GNU make debugger in case you need to debug makefiles
Welcome to Programmer Humor!
This is a place where you can post jokes, memes, humor, etc. related to programming!
For sharing awful code theres also Programming Horror.