### `startup` and `shutdown` together

There's a high chance that the logic for your *startup* and *shutdown* is connected, you might want to start something and then finish it, acquire a resource and then release it, etc.

Doing that in separated functions that don't share logic or variables together is more difficult as you would need to store values in global variables or similar tricks.

## Benchmarks and speed

When you check the benchmarks, it is common to see several tools of different types compared as equivalent.

Specifically, to see Uvicorn, Starlette and FastAPI compared together (among many other tools).

The simpler the problem solved by the tool, the better performance it will get. And most of the benchmarks don't test the additional features provided by the tool.

The hierarchy is like:

	AllObjectFacts func() []ObjectFact

	/* Further fields may be added in future. */
}

// PackageFact is a package together with an associated fact.
type PackageFact struct {
	Package *types.Package
	Fact    Fact
}

// ObjectFact is an object together with an associated fact.
type ObjectFact struct {
	Object types.Object
	Fact   Fact
}

 */
internal class KaFirSessionProvider(project: Project) : KaBaseSessionProvider(project) {
    // `KaFirSession`s must be soft-referenced to allow simultaneous garbage collection of an unused `KaFirSession` together
    // with its `LLFirSession`.
    private val cache: ConcurrentMap<KtModule, KaSession> = ContainerUtil.createConcurrentSoftValueMap()

    init {
        LowMemoryWatcher.register(::clearCaches, project)
    }

     * {@linkplain org.apache.maven.api.JavaPathType#patchModule(String) handled in a special way}.
     *
     * <h4>Design note</h4>
     * All types of path are determined together because they are sometime mutually exclusive.
     * For example, an artifact of type {@value org.apache.maven.api.Type#JAR} can be placed
     * either on the class-path or on the module-path. The project needs to make a choice

     * But if this type was created by {@code JavaPathType.patchModule("foo.bar")}, then this method returns
     * {@code "PATCH_MODULE:foo.bar"}.
     *
     * @return the programmatic name together with the module name on which it applies
     * @see #toString()
     */
    @Nonnull
    String id();

    /**
     * Returns the name of the tool option for this path. For example, if this path type

		// Parse //go:build expression.
		x, _ = constraint.Parse(p.commentTextAt(p.goBuild[0]))
	}

	var block []byte
	if x == nil {
		// Don't have a valid //go:build expression to treat as truth.
		// Bring all the lines together but leave them alone.
		// Note that these are already tabwriter-escaped.
		for _, pos := range p.goBuild {
			block = append(block, p.lineAt(pos)...)
		}
		for _, pos := range p.plusBuild {

percent     output total percentage of statements covered
pkglist     output list of package import paths
func        output coverage profile information for each function
merge       merge data files together
subtract    subtract one set of data files from another set
intersect   generate intersection of two sets of data files
debugdump   dump data in human-readable format for debugging purposes
`)

# See the License for the specific language governing permissions and
# limitations under the License.

# This command checks that the built commands can function together for
# simple scenarios.  It does not require Docker.

set -o errexit
set -o nounset
set -o pipefail

# start the cache mutation detector by default so that cache mutators will be found

    implementation(libs.jetty)
    implementation(libs.jettyServlet)
    implementation(libs.littleproxy)
    implementation(libs.mavenResolverSupplier) {
        because("For ApiMavenResolver. Wires together implementation for maven-resolver-api")
    }
    implementation(libs.maven3ResolverProvider) {
        because("For ApiMavenResolver. Provides MavenRepositorySystemUtils")
    }
    implementation(libs.nativePlatform)