Git submodules were a pain every single time I had to do more with them than just git clone --recurse-submodules.
You wouldn't have to do anything more with them than just git clone --recurse-submodules
Less user-friendly for every SFML user due to extra setup step (you can expect 100s of forum posts "why does my code not compile")
It can be made extremely simple. We can use cmake show a warning if the user hasn't cloned the submodules, telling them exactly which command to run. We can also use cmake to actually check out the submodules if the user hasn't already
We introduce a third-party dependency. If that third-party repository goes down, SFML will not be possible to build, with no backup (rolling back to previous version past now won't work)
Given all the repositories except one are hosted on github, the likelihood of this being an issue is almost nil. If it's a concern we can also easily mirror them in repos we have control over
It's not even clear if all the dependencies we currently use have official and stable Git repos. If not, we would need to provide a mirror (i.e. extra maintenance).
They all have official git repositories, and even IF we were to mirror them (which I don't think we need to do) the maintenance would be equal to maintaining the source in the SFML repo (i.e. almost nil)
subtree looks interesting. Haven't tried it myself but worth considering. I'd be interested to see and try a working example of it
And I would appreciate if the decision were made based on technical arguments, not polls from a handful of people that happen to be around at the time the matter is discussed
I think we've pretty much already covered all the technical arguments, there's not really too many facets to discuss. At this point it comes down to personal preference, so a poll seems reasonable.
In the interest of fairness, here are the submodule advantages that were already mentioned:
- Better visibility over dependency versions
- Easier testing of newer dependency versions (just git checkout/pull the revision you want to test)
- Easier access to dependency history for bisecting/debugging/testing
- Less risk of human error when updating or changing dependencies
- Easier to contribute changes upstream
As I said before I don't think there's a clear technical reason to choose one or the the other (They are almost identical in practice) so we just need a decision made. It's super easy to change and the implementation is pretty much done. We just need a decision so this doesn't turn into another dead discussion