### Dokumentation live

Während der lokalen Entwicklung gibt es ein Skript, das die Site erstellt, auf Änderungen prüft und direkt neu lädt (Live Reload):

<div class="termy">

```console
$ python ./scripts/docs.py live

<span style="color: green;">[INFO]</span> Serving on http://127.0.0.1:8008

    def collection = new CachingTaskInputFileCollection(TestFiles.resolver(), TestFiles.patternSetFactory, DefaultTaskDependencyFactory.withNoAssociatedProject(), Stub(PropertyHost))

    def "results are live prior to task execution"() {
        def files = []
        def f1 = tmpDir.file("f1")
        def f2 = tmpDir.file("f2")
        collection.from(files)

        expect:
        collection.files.empty

				t.Errorf("Error applying object: %v", err)
			}

			accessor := meta.NewAccessor()
			annotations, err := accessor.Annotations(f.Live())
			if err != nil {
				t.Errorf("Failed to access annotations: %v", err)
			}
			if annotations == nil {
				t.Errorf("No annotations on obj: %v", f.Live())
			}
			lastApplied, ok := annotations[internal.LastAppliedConfigAnnotation]
			if ok || len(lastApplied) > 0 {

/**
 * <p>A {@code DomainObjectCollection} is a specialised {@link Collection} that adds the ability to receive modification notifications and use live filtered sub collections.</p>
 *
 * <p>The filtered collections returned by the filtering methods, such as {@link #matching(Closure)}, return collections that are live. That is, they reflect

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// See import_test.go. This is the half that lives in the runtime package.

// TODO: Generate this

package runtime

type TestingT interface {
	Cleanup(func())
	Error(args ...any)
	Errorf(format string, args ...any)
	Fail()
	FailNow()
	Failed() bool
	Fatal(args ...any)

	sink = y

	panic(nil)

	// After the recover we reach the deferreturn, which
	// copies the heap version of x back to the stack.
	// It gets the pointer to x from a stack slot that was
	// not marked as live during the call to runtime.GC().
}

var sinkint int

func g(p *int) (x [20]byte) {
	// Initialize x.
	for i := range x {
		x[i] = byte(i)
	}

	// Force x to be allocated on the heap.
	sink = &x

		Example: `  # Analyze the current live cluster
  istioctl analyze

  # Analyze the current live cluster for a specific revision
  istioctl analyze --revision 1-16

  # Analyze the current live cluster, simulating the effect of applying additional yaml files
  istioctl analyze a.yaml b.yaml my-app-config/

  # Analyze the current live cluster, simulating the effect of applying a directory of config recursively

    <tr>
        <td>Frees</td>
        <td id="Frees">{{.Frees}} objects</td>
        <td>Cumulative count of heap objects freed.</td>
    </tr>

    <tr>
        <td>Live</td>
        <td id="Live">0 objects</td>
        <td>Count of live heap objects.</td>
    </tr>

    <tr>
        <td>HeapAlloc</td>
        <td id="HeapAlloc">{{.HeapAlloc}} bytes</td>
        <td>Allocated heap objects.</td>
    </tr>

// the lock across those operations.
//
// It is worse to inherit some file descriptors than others.
// If a non-malicious child accidentally inherits an open ordinary file,
// that's not a big deal. On the other hand, if a long-lived child
// accidentally inherits the write end of a pipe, then the reader
// of that pipe will not see EOF until that child exits, potentially
// causing the parent program to hang. This is a common problem

 *
 * As the necessary attributes are not present on the consumer's compileClasspath configuration until the
 * beforeLocking callback method is called, the previous incorrect behavior of the ArtifactView was to select without
 * considering these attributes.  This has been corrected to use a "live" view