### SIG Multi-cluster (formerly known as SIG Federation)

[SIG Multi-cluster][] is responsible for infrastructure that supports
the efficient and reliable management of multiple Kubernetes clusters,
and applications that run in and across multiple clusters.

For the 1.8 release, SIG Multicluster focussed on expanding the set of

* A new client `k8s.io/client-go/metadata.Client` has been added for accessing objects generically. This client makes it easier to retrieve only the metadata (the `metadata` sub-section) from resources on the cluster in an efficient manner for use cases that deal with objects generically, like the garbage collector, quota, or the namespace controller. The client asks the server to return a `meta.k8s.io/v1 PartialObjectMetadata` object for list, get, delete, watch, and patch...

of this functionality is to improve efficiency: manually freeing memory
before a garbage collection delays that cycle. Less frequent cycles means
the CPU cost of the garbage collector is incurred less frequently.

This functionality in this package is mostly captured in the Arena type.
Arenas allocate large chunks of memory for Go values, so they're likely to
be inefficient for allocating only small amounts of small Go values. They're

   * efficiency. The base class implementation determines successive Unicode code points and invokes
   * {@link #escape(int)} for each of them. If the semantics of your escaper are such that code
   * points in the supplementary range are either all escaped or all unescaped, this method can be
   * implemented more efficiently using {@link CharSequence#charAt(int)}.
   *

in mind. It is strongly typed and garbage-collected and has explicit
support for concurrent programming.  Programs are constructed from
<i>packages</i>, whose properties allow efficient management of
dependencies.
</p>

<p>
The syntax is compact and simple to parse, allowing for easy analysis
by automatic tools such as integrated development environments.
</p>

Blocking APIs may be inefficient because you hold a thread idle while waiting on the network. Threads are expensive because they have both a memory overhead and a context-switching overhead.

#### Framed protocols

// sufficient to initialize a [Buffer].
func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }

// NewBufferString creates and initializes a new [Buffer] using string s as its
// initial contents. It is intended to prepare a buffer to read an existing
// string.
//
// In most cases, new([Buffer]) (or just declaring a [Buffer] variable) is
// sufficient to initialize a [Buffer].

Bei einer **Web-API** bedeutet das normalerweise, diese auf einem **entfernten Rechner** zu platzieren, mit einem **Serverprogramm**, welches gute Leistung, Stabilität, usw. bietet, damit Ihre **Benutzer** auf die Anwendung effizient und ohne Unterbrechungen oder Probleme **zugreifen** können.

Das steht im Gegensatz zu den **Entwicklungsphasen**, in denen Sie ständig den Code ändern, kaputt machen, reparieren, den Entwicklungsserver stoppen und neu starten, usw.

  }

  /**
   * A sensible, albeit inefficient, definition of {@link #size} in terms of {@link #entrySet}. If
   * you override {@link #entrySet}, you may wish to override {@link #size} to forward to this
   * implementation.
   *
   * @since 7.0
   */
  protected int standardSize() {
    return Multisets.linearTimeSizeImpl(this);
  }

  /**
   * A sensible, albeit inefficient, definition of {@link #equals} in terms of {@code

        assertWithMessage("Pearson's correlation coefficient of %s", values)
            .that(pearsonsCorrelationCoefficient)
            .isNaN();
        assertWithMessage("Pearson's correlation coefficient by addAll(PairedStats) of %s", values)
            .that(pearsonsCorrelationCoefficient)
            .isNaN();
      } else {
        assertWithMessage("Pearson's correlation coefficient of %s", values)