@menu
* Introduction to issues::
+* Bug Squad checklists::
* Issue classification::
* Adding issues to the tracker::
-* Checking and verifying issues::
* Summary of project status::
* Finding the cause of a regression::
@end menu
@node Introduction to issues
@section Introduction to issues
-First, @qq{issue} isn't just a politically-correct term for
-@qq{bug}. We use the same tracker for feature requests and code
-TODOs, so the term @qq{bug} wouldn't be accurate.
+@warning{Unless otherwise specified, all the tasks in this chapter
+are @qq{simple} tasks: they can be done by a normal user with
+nothing more than a web browser, email, and lilypond.}
-Second, the classification of what counts as a bug vs. feature
-request, and the priorities assigned to bugs, are a matter of
-concern @strong{for developers only}. The Bug Squad will classify
-issues according to the guidelines given by developers.
+@qq{Issues} isn't just a politically-correct term for @qq{bug}.
+We use the same tracker for feature requests and code TODOs, so
+the term @qq{bug} wouldn't be accurate. Despite the difference
+between @qq{issue} and @qq{bug}, we call our team of contributors
+who organize issues the @emph{Bug Squad}.
-If you are curious about the classification, read on, but please
-don't complain that your particular issue should have higher
-priority or counts as a bug rather than a feature request.
+The Bug Squad is mainly composed of non-programmers -- their job
+is to @emph{organize} issues, not solve them. Their duties
+include removing false bug reports, ensuring that any real bug
+report contains enough information for developers, and checking
+that a developer's fix actually resolves the problem.
+
+
+@node Bug Squad checklists
+@section Bug Squad checklists
+
+We highly recommend that you configure your email client to put
+messages from:
+
+@example
+@@googlecode.com
+@end example
+
+@noindent
+into a separate folder than emails to @code{bug-lilypond}.
+
+
+@subsubheading New emails to @code{bug-lilypond}
+
+Every new email to @code{bug-lilypond} should be handled within
+@strong{24 hours} in the first method which is applicable:
+
+@enumerate
+
+@item
+If the email is a question about how to use LilyPond, direct them
+politely to @code{lilypond-user}.
+
+@item
+If a bug report is not in the form of a Tiny example, direct the
+user to resubmit the report after reading @rweb{Tiny examples}.
+
+@item
+If the behavior is expected, the user should be told to read the
+documentation, or asked to clarify how he misread the docs and how
+the docs could be improved.
+
+@item
+If the issue already exists in the tracker, send an email to that
+effect.
+
+@item
+Ask the user for more information, such as lilypond version number
+(if not given) and operating system (if this is a suspected cause
+of the problem).
+
+@item
+Accept the report as described in
+@ref{Adding issues to the tracker}.
+
+@end enumerate
+
+
+@subheading Updates / discussion about issues
+
+We try to keep discussions about issues on the tracker, but
+sometimes it spills over onto email. If discussion has ended with
+no patch / resolution and at least @strong{3 days} have passed,
+then either:
+
+@itemize
+
+@item
+Summarize the recent discussion on the tracker, and add a link to
+the original discussion.
+
+@item
+Add the comment @qq{there was some technical discussion which I
+could not understand}, and include a link to the original
+discussion.
+
+We do not expect Bug Squad members to be programmers, or even to
+be moderately-skilled users. Your job is to keep track of issue
+reports; it is @emph{perfectly acceptable} to not understand
+discussions between advanced users and/or developers.
+
+@end itemize
+
+
+@subheading Regular maintenance
+
+After @strong{every release} (both stable and unstable):
+
+@itemize
+
+@item
+Regression test comparison: if anything has changed suspiciously,
+ask if it was deliberate. The official comparison is online, at:
+
+@example
+@uref{http://lilypond.org/test/}
+@end example
+
+@item
+Issues to verify: try to reproduce the bug with the latest
+version; if you cannot reproduce the bug, mark the item
+@qq{Verified} (i.e. @qq{the fix has been verified to work}).
+
+@example
+@uref{http://code.google.com/p/lilypond/issues/list?can=7}
+@end example
+
+@end itemize
+
+Once every @strong{two weeks} or so:
+
+@itemize
+
+@item
+Check for any incorrectly-classified items in the tracker. This
+generally just means looking at the grid to see any items without
+a Type or Priority.
+
+@item
+Check for any items with @code{label:patch}. If it's been more
+than a week since the last action on the issue, send an email to
+-devel to remind them about it. If the patch was withdrawn for
+more work, then remove the @code{patch} label.
+
+@example
+@uref{http://code.google.com/p/lilypond/issues/list?can=2&q=label:patch}
+@end example
+
+@end itemize
+
+@subheading Irregular maintenance
+
+@warning{These tasks are a lot of work; gathering more volunteers
+to help is definitely recommended. However, the Bug Squad should
+handle the organization and training of new volunteers.}
+
+Once every year or two:
+
+@itemize
+
+@item
+Checking all regtests: although we have a system for checking the
+regtests between two versions, occasionally a bug will slip
+through the cracks. It is therefore good to manually examine all
+the regtests (compare the images to the text description).
+
+@item
+Checking all issues: we try to mark each Issue @q{fixed} when we
+fix it, but occasionally one or two issues will slip through the
+cracks. It is therefore good to check all Issues. If you see the
+same (broken) output as the initial report, then simply post a
+@qq{Problem still exists in 2.x.y} message to the issue.
+
+@end itemize
@node Issue classification
@section Issue classification
+The Bug Squad should classify issues according to the guidelines
+given by developers. Every issue should have a Status, Type, and
+Priority; the other fields are optional.
-@subheading Status
+@subheading Status (mandatory)
Open issues:
@end itemize
-@subheading Owner
+@subheading Owner (optional)
Newly-added issues should have @emph{no owner}. When a
contributor indicates that he has Started or Fixed an item, he
should become the owner.
-
-@subheading Type
+@subheading Type (mandatory)
The issue's Type should be the first relevant item in this list.
@item
Type-Scripts: problem or desired feature in the non-build-system
scripts. Mostly used for convert-ly, lilypond-book, etc.
-
@item
Type-Enhancement: a feature request for the core program. The
distinction between enhancement and defect isn't extremely clear;
@end itemize
-@subheading Priority
+@subheading Priority (mandatory)
Currently, only Critical items will block a stable release.
Medium/Low.
-@subheading Opsys
+@subheading Opsys (optional)
Issues that only affect specific operating systems.
-@subheading Other items
+@subheading Other items (optional)
Other labels:
improvements to the build system, or @qq{helper} python scripts.
@item
-Bounty: somebody is willing to pay for the fix.
+Bounty: somebody is willing to pay for the fix. Only add this tag
+if somebody has offered an exact figure in US dollars or euros.
@item
Warning: graphical output is fine, but lilypond prints a
@end itemize
+If you particularly want to add an label not in the list, go
+ahead, but this is not recommended.
+
@node Adding issues to the tracker
@section Adding issues to the tracker
-This should only be done by the Bug Squad or experienced
+@warning{This should only be done by the Bug Squad or experienced
developers. Normal users should not do this; instead, they should
-follow the guidelines for @rweb{Bug reports}.
+follow the guidelines for @rweb{Bug reports}.}
+In order to assign labels to issues, Bug Squad members should log
+in to their google account before adding an item.
-@node Checking and verifying issues
-@section Checking and verifying issues
+@subsubheading Normal issues
-After each release (both stable and unstable):
+@enumerate
-@itemize
+@item
+Check if the issue falls into any previous category given on the
+relevant checklists in @ref{Bug Squad checklists}. If in doubt,
+add a new issue for a report. We would prefer to have some
+incorrectly-added issues rather than lose information that should
+have been added.
@item
-Regression test comparison: check the relevant version in
-@uref{http://lilypond.org/test/}.
+Add the issue and classify it according to the guidelines in
+@ref{Issue classification}. In particular, the item should have
+@code{Status}, @code{Type-}, and @code{Priority-} labels.
@item
-Issues to verify:
-@uref{http://code.google.com/p/lilypond/issues/list?can=7}.
+After adding the issue, please send a response email to the same
+group(s) that the initial patch was sent to. If the initial email
+was sent to multiple mailing lists (such as both @code{user} and
+@code{bugs}), then reply to all those mailing lists as well. The
+email should contain a link to the issue you just added.
-@end itemize
+@end enumerate
-Once every two weeks or so:
-@itemize
+@subsubheading Patch reminders
-@item
-Check for any items with @code{label:patch}. If it's been more
-than a week since the last action on the issue, send an email to
--devel to remind them about it. If the patch was withdrawn for
-more work, then remove the @code{patch} label.
+@warning{This is not a Bug Squad responsibility; we have a
+separate person handling this task.}
-@example
-@uref{http://code.google.com/p/lilypond/issues/list?can=2&q=label:patch}
-@end example
+There is a special category of issues: reminders of an existing
+patch. These should be added if a patch has been sent to a
+lilypond mailing list (generally @code{lilypond-devel}, but they
+sometimes appear on @code{bug-lilypond} as well) and has had no
+discussion for at least @strong{3 days}. Do not add issues for
+patches under active discussion.
-@end itemize
-
-Once every year or so:
-
-@itemize
+Before adding a patch-reminder issue, do a quick check to see if
+it was pushed without sending any email. This can be checked for
+searching for relevant terms (from the patch subject or commit
+message) on the webgit page:
-@item
-Checking all regtests: although we have a system for checking the
-regtests between two versions, occasionally a bug will slip
-through the cracks. It is therefore good to manually examine all
-the regtests (compare the images to the text description).
+@example
+@uref{http://git.savannah.gnu.org/gitweb/?p=lilypond.git}
+@end example
-@item
-Checking all issues: we try to mark each Issue @q{fixed} when we
-fix it, but occasionally one or two issues will slip through the
-cracks. It is therefore good to check all Issues. If you see the
-same (broken) output as the initial report, then simply post a
-"Problem still exists in 2.x.y" message to the issue.
+After adding the issue, please send a response email to the same
+group(s) that the initial patch was sent to. If the initial email
+was sent to multiple mailing lists (such as both @code{bugs} and
+@code{devel}), then reply to all those mailing lists as well. The
+email should contain a link to the issue you just added.
-@end itemize
@node Summary of project status
@uref{http://code.google.com/p/lilypond/issues/list?can=2&q=label:Frog&mode=grid&y=Priority&x=Type&cells=ids}
@end example
+
@node Finding the cause of a regression
@section Finding the cause of a regression
+@warning{This is not a @qq{simple} task; it requires a fair amount
+of technical knowledge.}
+
Git has special functionality to help tracking down the exact
commit which causes a problem. See the git manual page for
@code{git bisect}. This is a job that non-programmers can do,
although it requires familiarity with git, ability to compile
-LilyPond, and generally a fair amount of technical knowledge.
+LilyPond, and generally a fair amount of technical knowledge. An
+in-depth explanation of this process will not be given here.
Even if you are not familiar with git or are not able to compile
-LilyPond you can still help to narrow down the cause of a regression
-simply by downloading the binary releases of different LilyPond
-versions and testing them for the regression. Knowing which version
-of LilyPond first exhibited the regression is helpful to a developer
-as it shortens the @code{git bisect} procedure described above.
+LilyPond you can still help to narrow down the cause of a
+regression simply by downloading the binary releases of different
+LilyPond versions and testing them for the regression. Knowing
+which version of LilyPond first exhibited the regression is
+helpful to a developer as it shortens the @code{git bisect}
+procedure described above.
Once a problematic commit is identified, the programmers' job is
much easier. In fact, for most regression bugs, the majority of
projects / lilypond.git / blobdiff