Tested with self build...
I'm curious why suddenly many people, most notably Anatoly-os, are using self builds to test bugs in MuseScore. In the past bugs were reported against nightlies. This assured consistency in versions being tested. Others can download the same build and run more tests to help track down the problem. My concern is that one person's self build might have some different code than the nightly.
One problem with reporting bugs against a self build is that others cannot test bug against the same build, is that one person may have a bug while another does not.
I haven't started testing 3.0 yet because I test while doing my daily work in MuseScore and don't want to lose any of my work.
Comments
Well, actually self builds are based on the very same code of nightly build, the only difference is that they are built locally by the developer instead of being built by the continuous integration server.
And this is done mainly to make them "debug" builds, i.e. they contain debugging symbols, which help the developer in finding where exactly (e.g. file and line of code) the bug (for example a crash) is born.
From the code point of view, as I said, there is no difference; it is only a difference in compilation flags.
Nightly builds on the other hand are "release" build, i.e. they are more optimized towards performance (and smaller file size), so that testing is much easier on them (debug builds are definitely slower than release builds).
Edit: I forgot to say that usually when talking about self builds the github revision is indicated; the nightly build corresponding to that revision should exhibit the same bug (the only exception is for possible bugs related to speed of computation, for obviuos reasons, and cases of differences between debug and release builds such as some places in which debug builds are made to crash if a corruption is present while the release build can go on even in presence of that corruption, so that in debug build it is easier to catch early corruptions).
I can't speak for anyone else, but when testing development versions, I've virtually always used my own self-builds - this goes back maybe six years. Nightlies to me are useful for non-developers because it's usually not easy for them to build themselves, but developers will generally want to use self-builds so we can run under the debugger and get right to the heart of the problem. Having to take the separate step of downloading a nightly and test again there would really slow the process down. I normally would only do that if I have reason to think maybe some change I am working on may have inadvertently caused a new problem.
It's true that very occasionally this leads to some sort of confusion where one person can reproduce but another cannot, but in my experience this doesn't happen very often. I mean, sure, it's common to not be able to reproduce problems, but it's seldom for this reason. And when it does, that's actually sometimes a nice clue, because by checking the git logs, we can see exactly which commits are different.
Very good explanations.