Each CMake release distributes its own set of library-specific (!) find_package modules.
This is a gross misunderstanding and misrepresentation of CMake. CMake ships with CMake configure scripts for some popular libraries, but their goal is to lower the barrier to entry to CMale by supportinh projects which haven’t been properly onboarded onto CMake by their maintainers.
Think of it as a the-chicken-and-the-egg problem, but tied to CMake’s adoption. You want to use CMake but you can’t just properly consume a dependency because it doesn’t export it’s own CMake config script, so what do you do? CMake supports those cases by means of user-provided CMake Find modules, which each project has to roll out on their own and ship along with their source code. That sounds like a lot of repetitive work, doesn’t it? So why not provide CMake-provided scripts with the distribution?
My impression is that (…)
If the worst point you can make about CMake is the cmake config scripts it bundles, then I’m afraid you are very opinionated over irrelevant details that are immaterial to the discussion.
This is a gross misunderstanding and misrepresentation of CMake.
You lead with this, but all I see in your reply is an explanation of why it works exactly the way I described. That explanation apparently it is: “because not everyone in the ecosystem acts the way CMake developers would want them to”, which I read as “CMakes design for external dependencies is broken.” The fact is, where we are right now, today, the find_package/config script design in CMake frequently makes resolving external dependencies far more painful than it already is without that complication.
That sounds like a lot of repetitive work, doesn’t it? So why not provide CMake-provided scripts with the distribution?
I believe my previous reply gives a very clearly answer: because we get stuck in a situation with multiple competing providers of ‘scripts’ that compete against each other and may apparently all change in backwards breaking ways between releases of CMake, releases of the library in question, and releases of package managers like vcpkg who have taken on themselves to fill in missing scripts.
In the end, it is me who have to dig deep into someone else’s mess of CMakeLists.txt:s to try to unravel the mystery of what feature identifiers they expect from that external depedency and how they expect them to work in the find_package/config script the developers happened to use at the time, so I can then go on an archaeological expedition through all possible providers of that config - including older versions of CMake itself to track it down. Multiply with the number of dependencies - which sometimes is up in the hundreds - and it should be clear why this is a horrible, horrible design of a build system.
If we had to stay with CMake’s broken design for this, at the very least it would need some form of declaration of dependency config scripts with a provider name and a semantic version. That way the problem would at least be solvable.
However, it is more or less only CMake that has this issue in its attempt to be so ‘meta’ about everything. Libraries already come with a build-system independent way to specify features: they are split over several library files and software using that dependency choose which ones to link with - using file names. This works well in nearly every other build system. I don’t get the motivation to try to abstract this into an interface that (for the reasons we’ve discussed above) introduces another intermediate dependency layer.
If the worst point you can make about CMake is the cmake config scripts it bundles, then I’m afraid you are very opinionated over irrelevant details that are immaterial to the discussion.
IMO the main task of a build system is to manage inter- and intradependencies to build the software correctly. So, to me, this failure is truly a fundamental strike against it. If I cannot build your software because I cannot sort out your undeclared, unversioned implicit ‘config’ dependencies, I don’t have much use for other features your build system may or may not provide.
That explanation apparently it is: “because not everyone in the ecosystem acts the way CMake developers would want them to”, which I read as “CMakes design for external dependencies is broken.”
Not really, it just means you manifest a blatant and critical misunderstanding of what build systems in general do, and in particular what are CMake’s responsibilities.
As you’re guiding your opinion and expectations on a mental model that’s fundamentally broken while being oblivious to the brokenness of the mental model, instead of identifying the real problem you’re falling back to blame tools.
The issue is quite simple: CMake is a high-level abstractions which is used to generate arbitrary build systems on arbitrary platforms. No platform provides a standard way to make libraries or modules available. At best, Unix-like OSes store include headers and static and shared libraries in specific locations in the file system, but each library can and often does allow users to customize it’s installation. There is no way platform-indendent or platform-specific way to configure these. How do you solve this issue?
CMake solves this issue in a very simple way: library vendors can export CMake config files that downstream dependencies can use to configure their CMake projects. The hard problem becomes a solved problem. However, this requires library vendors to own this leg of the process. Not all projects do. So what can be done about those?
For projects whose managers don’t support CMake, CMake provides two mitigations: it ships with CMake-vended config scripts for popular libraries, and allows users to provide their own custom CMake Find modules.
Describing this approach as “broken” is quite honestly a very ignorant and clueless thing to do.
The fact is, where we are right now, today, the find_package/config script design in CMake frequently makes resolving external dependencies far more painful than it already is without that complication.
This personal assertion makes no sense at all and has no basis in reality. The only thing that find_package does is check if someone made available a script that tells CMake how to configure a dependency. If no script was provided, CMake makes the package as not found. If a script was found but it’s sanity checks fail then CMake marks the package as not found. If a script is found and it’s sanity checks passed, CMake can use the targets in builds. That’s all there is to it. Pain-free.
The is only one caveat: you have to have some idea of what you’re doing, and bad workmen tend to blame their tools.
This is a gross misunderstanding and misrepresentation of CMake. CMake ships with CMake configure scripts for some popular libraries, but their goal is to lower the barrier to entry to CMale by supportinh projects which haven’t been properly onboarded onto CMake by their maintainers.
Think of it as a the-chicken-and-the-egg problem, but tied to CMake’s adoption. You want to use CMake but you can’t just properly consume a dependency because it doesn’t export it’s own CMake config script, so what do you do? CMake supports those cases by means of user-provided CMake Find modules, which each project has to roll out on their own and ship along with their source code. That sounds like a lot of repetitive work, doesn’t it? So why not provide CMake-provided scripts with the distribution?
If the worst point you can make about CMake is the cmake config scripts it bundles, then I’m afraid you are very opinionated over irrelevant details that are immaterial to the discussion.
You lead with this, but all I see in your reply is an explanation of why it works exactly the way I described. That explanation apparently it is: “because not everyone in the ecosystem acts the way CMake developers would want them to”, which I read as “CMakes design for external dependencies is broken.” The fact is, where we are right now, today, the find_package/config script design in CMake frequently makes resolving external dependencies far more painful than it already is without that complication.
I believe my previous reply gives a very clearly answer: because we get stuck in a situation with multiple competing providers of ‘scripts’ that compete against each other and may apparently all change in backwards breaking ways between releases of CMake, releases of the library in question, and releases of package managers like vcpkg who have taken on themselves to fill in missing scripts.
In the end, it is me who have to dig deep into someone else’s mess of CMakeLists.txt:s to try to unravel the mystery of what feature identifiers they expect from that external depedency and how they expect them to work in the find_package/config script the developers happened to use at the time, so I can then go on an archaeological expedition through all possible providers of that config - including older versions of CMake itself to track it down. Multiply with the number of dependencies - which sometimes is up in the hundreds - and it should be clear why this is a horrible, horrible design of a build system.
If we had to stay with CMake’s broken design for this, at the very least it would need some form of declaration of dependency config scripts with a provider name and a semantic version. That way the problem would at least be solvable.
However, it is more or less only CMake that has this issue in its attempt to be so ‘meta’ about everything. Libraries already come with a build-system independent way to specify features: they are split over several library files and software using that dependency choose which ones to link with - using file names. This works well in nearly every other build system. I don’t get the motivation to try to abstract this into an interface that (for the reasons we’ve discussed above) introduces another intermediate dependency layer.
IMO the main task of a build system is to manage inter- and intradependencies to build the software correctly. So, to me, this failure is truly a fundamental strike against it. If I cannot build your software because I cannot sort out your undeclared, unversioned implicit ‘config’ dependencies, I don’t have much use for other features your build system may or may not provide.
Not really, it just means you manifest a blatant and critical misunderstanding of what build systems in general do, and in particular what are CMake’s responsibilities.
As you’re guiding your opinion and expectations on a mental model that’s fundamentally broken while being oblivious to the brokenness of the mental model, instead of identifying the real problem you’re falling back to blame tools.
The issue is quite simple: CMake is a high-level abstractions which is used to generate arbitrary build systems on arbitrary platforms. No platform provides a standard way to make libraries or modules available. At best, Unix-like OSes store include headers and static and shared libraries in specific locations in the file system, but each library can and often does allow users to customize it’s installation. There is no way platform-indendent or platform-specific way to configure these. How do you solve this issue?
CMake solves this issue in a very simple way: library vendors can export CMake config files that downstream dependencies can use to configure their CMake projects. The hard problem becomes a solved problem. However, this requires library vendors to own this leg of the process. Not all projects do. So what can be done about those?
For projects whose managers don’t support CMake, CMake provides two mitigations: it ships with CMake-vended config scripts for popular libraries, and allows users to provide their own custom CMake Find modules.
Describing this approach as “broken” is quite honestly a very ignorant and clueless thing to do.
This personal assertion makes no sense at all and has no basis in reality. The only thing that
find_packagedoes is check if someone made available a script that tells CMake how to configure a dependency. If no script was provided, CMake makes the package as not found. If a script was found but it’s sanity checks fail then CMake marks the package as not found. If a script is found and it’s sanity checks passed, CMake can use the targets in builds. That’s all there is to it. Pain-free.The is only one caveat: you have to have some idea of what you’re doing, and bad workmen tend to blame their tools.