Also, the best approach was to use already existing standards.

So, before even starting to code **FastAPI**, I spent several months studying the specs for OpenAPI, JSON Schema, OAuth2, etc. Understanding their relationship, overlap, and differences.

## Design { #design }

Then I spent some time designing the developer "API" I wanted to have as a user (as a developer using FastAPI).

     * #recordMisses}, this method should only be called by the loading thread.
     *
     * @param loadTime the number of nanoseconds the cache spent computing or retrieving the new
     *     value
     */
    @SuppressWarnings("GoodTime") // should accept a java.time.Duration
    void recordLoadSuccess(long loadTime);

    /**

     * #recordMisses}, this method should only be called by the loading thread.
     *
     * @param loadTime the number of nanoseconds the cache spent computing or retrieving the new
     *     value
     */
    @SuppressWarnings("GoodTime") // should accept a java.time.Duration
    void recordLoadSuccess(long loadTime);

    /**

     */
    private final MavenProject project;

    /**
     * The build time of the project in milliseconds.
     */
    private final Duration wallTime;

    /**
     * The total amount of time spent for to run mojos in milliseconds.
     */
    private final Duration execTime;

    /**
     * Creates a new build summary for the specified project.
     *

* **Easier onboarding**: New contributors have clear guidance on which spelling to use
* **Better searchability**: Finding code and documentation becomes more predictable
* **Reduced review friction**: Less time spent on spelling corrections during PR reviews
* **Professional appearance**: Consistent APIs and documentation appear more polished
* **Clearer contribution guidelines**: [CONTRIBUTING.md](../../CONTRIBUTING.md) now includes this requirement

		dur = 0
	}
	a.Total += int64(dur)
	a.N++
}

// Merge b into a.
func (a *AccElem) merge(b AccElem) {
	a.N += b.N
	a.Total += b.Total
	a.Size += b.Size
}

// Avg returns average time spent.
func (a AccElem) avg() time.Duration {
	if a.N >= 1 && a.Total > 0 {
		return time.Duration(a.Total / a.N)
	}
	return 0
}

// asTimedAction returns the element as a madmin.TimedAction.

		}
		atomic.StoreInt64(&dt.timeout, timeout)
	} else if failPct < dynamicTimeoutDecreaseThresholdPct {
		// We are hitting the timeout relatively few times,
		// so decrease the timeout towards 25 % of maximum time spent.
		maxDur = maxDur * 125 / 100

		timeout := atomic.LoadInt64(&dt.timeout)
		if maxDur < time.Duration(timeout) {
			// Move 50% toward the max.
			timeout = (int64(maxDur) + timeout) / 2
		}

        }
        return sb.toString();
      }
    },
    // It really seems like this should be faster than TO_BYTE_ARRAY_NEW_STRING.  But it just isn't
    // my best guess is that the jdk authors have spent more time optimizing that callpath than this
    // one. (StringCoding$StringDecoder vs. StreamDecoder).  StringCoding has a ton of special cases

	processLocksWriteTotalMD          = NewGaugeMD(processLocksWriteTotal, "Number of current WRITE locks on this peer")
	processCPUTotalSecondsMD          = NewCounterMD(processCPUTotalSeconds, "Total user and system CPU time spent in seconds")
	processGoRoutineTotalMD           = NewGaugeMD(processGoRoutineTotal, "Total number of go routines running")

     */
    int NTLMSSP_NEGOTIATE_ALWAYS_SIGN = 0x00008000;

    /**
     * Sent by the server in the Type 2 message to indicate that the
     * target authentication realm is a domain.
     */
    int NTLMSSP_TARGET_TYPE_DOMAIN = 0x00010000;

    /**
     * Sent by the server in the Type 2 message to indicate that the
     * target authentication realm is a server.
     */