* 先確認你是否能理解提問者的**目的**與使用情境。

* 接著看看問題（絕大多數是提問）是否**清楚**。

* 很多時候，提問是基於使用者自己想像中的解法，但可能有**更好**的方法。如果你能更理解他們的問題與使用情境，你也許能提出更好的**替代解法**。

* 如果你無法理解問題，請要求提供更多**細節**。

### 重現問題 { #reproduce-the-problem }

在大多數情況與問題中，都會與對方的**原始程式碼**有關。

很多時候他們只會貼出一小段程式碼，但那不足以**重現問題**。

* 你可以請他們提供一個[最小可重現範例](https://stackoverflow.com/help/minimal-reproducible-example)，讓你可以**複製貼上**並在本機執行，看到與他們相同的錯誤或行為，或更好地理解他們的使用情境。

         * large that doing the lookup is noticeably slower than redoing the work would be.
         *
         * Ideally we'd have a real eviction policy, but until we see a problem in practice, I hope
         * that this will suffice. I have not even benchmarked with different size limits.
         */
        if (validClasses.size() > 1000) {
          validClasses.clear();
        }

                // Don't want to have two workers pulling from the queue.
                return;
              } else {
                // Increment the run counter to avoid the ABA problem of a submitter marking the
                // thread as QUEUED after it already ran and exhausted the queue before returning
                // from execute().
                workerRunCount++;

   * response code like 404 or 500.
   *
   * @throws IOException if the request could not be executed due to cancellation, a connectivity
   *     problem or timeout. Because networks can fail during an exchange, it is possible that the
   *     remote server accepted the request before the failure.
   * @throws IllegalStateException when the call has already been executed.
   */

                    totalProblems, (totalProblems == 1) ? "problem was" : "problems were"));

            if (context.options().showErrors().orElse(false)) {
                for (BuilderProblem problem :
                        settingsResult.getProblems().problems().toList()) {
                    context.logger.warn(problem.getMessage() + " @ " + problem.getLocation());
                }
            }

     * in any IO with the server. Unlink <code>InputStream</code> value less than
     * the one provided will not be returned if it exceeds the end of the file
     * (if this is a problem let us know).
     */
    @Override
    public long skip(final long n) throws IOException {
        if (n > 0) {
            fp += n;
            return n;
        }
        return 0;
    }

    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("a", CLOSED).size());
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  @AndroidIncompatible // Reflection bug, or actual binary compatibility problem?
  public void testElementSetBridgeMethods() {
    for (Method m : TreeMultiset.class.getMethods()) {
      if (m.getName().equals("elementSet") && m.getReturnType().equals(SortedSet.class)) {
        return;
      }

For instance, whether they use an internal property (intentionally or accidentally), or whether they use an unstable feature that can change at any time.

Symmetrically, the same problem exists on the side of Gradle maintainers.
It should be clear when introducing a property what contract users can expect and what we can afford to provide.

   * for an RPC may wait for a similar call that requests a long timeout, or a call by an
   * unprivileged user may return a resource accessible only to a privileged user making a similar
   * call. To prevent this problem, create a key object that includes all values that affect the
   * result of the query. Or use {@code LoadingCache.get(K)}, which lacks the ability to refer to
   * state other than that in the key.
   *

         * in such a way that there can be a slash at the end of the path. This
         * causes problems matching keys in resolve() where an extra slash causes
         * a mismatch. This strips trailing slashes from all keys to eliminate
         * this problem.
         */
        int ki = key.length();
        while (ki > 1 && key.charAt(ki - 1) == '\\') {
            ki--;
        }