What hinders you *in trying* to create a minimum example?
1) Because it is veers toward being a ridiculous and arbitrary criteria. Speaking for
myself, the example presented in this case was ***clearly*** small
enough to debug. In my opinion, anyone saying otherwise either has a tangential axe to
grind, or is not familiar enough with the language to be of help.
No, you do not need a minimal example to solve a problem.
Of course, the less code there is, the easier it should be. And I implore everyone to attempt to remove as much as seems reasonable when they submit a question.
But to say things to the effect of "anyone helping you will have to start by creating a minimal example" is uber-rubbish. As long as you can immediately read the code and understand what it is attempting to do, then the example is sufficient.
If I were to critique the code in this case, I would rather emphasize the awkward formatting: Line up your
opening and closing braces, and use more consistent indentation, and more of it.
It is far easier to read pages of well-formatted code than it is to
comprehend a single convoluted _expression_.
The emphasis should not be about minimalism, but rather about clarity. These are not the same quality; too much minimalism tends to obscure rather than clarify.
2) Because often much of the "non-minimal" code
comes straight out of the docs. What kind of culture suggests that quoting code based on the docs is unfit for the basis of discussion on a user
group?
Because minimal examples fetishize the minutia of lilypond while obscuring the normal
complexity present even in meager scores, such that it becomes
needlessly complicated to apply the fix. I find it counterproductive to suggest that one should reduce an example
to be smaller than what is *musically* necessary--in particular, in
terms of the number of staves or voices in use.
Hammering on people to conform to the minimal example causes people to have extra iterations on the list, and wastes everyone's bandwidth: * a reasonable
(or possibly non-reasonable) example, * a follow-up (attempt at a) minimal
example (it will never truly be minimal), * once a solution is
suggested, a follow-up about how to solve the actual problem in the
first place, since it was not clear how to apply the solution of the
minimal example to the actual score, which has additional necessary
complexity.
Wouldn't it have been better to just provide a response to the first reasonable request?
3) My question to people complaining about the non-minimal-ness of this example is: Precisely which of these lines caused you to any extra time to debug? This was not a rambling several screens of undistilled raw source, but about two dozen lines, much of which is boilerplate.
The things you took out to make it minimal: did you take these out just to prove a point, or did you ***honestly*** think that removing, for example, the names of staves and voices, key signature, clefs, or reducing a piano staff to a parallel music _expression_ would actually identify or solve the problem with the duplicate time signature?
I don't think that anyone in this discussion misunderstands *how* to create a truly minimal example. It's just that there is an open question about how relevant it is, especially beyond a certain point.
Almost more importantly, there is also concern about the impact of how the attitude conveyed on this list about the requirements for minimal examples is a deterrent to cultivating the lilypond community.
I understand the intention of the requests (although not demands) for minimal examples. But, as someone who has spent a lifetime developing and debugging code, I can assure you that these demands are strictly unnecessary, and come across as whiny and unprofessional.
It should be possible to encourage people to improve their code, provide reasonable guidelines for submissions, and not come across as hostile or insulting.