StabilityLevel:    metrics.ALPHA,
			DeprecatedVersion: "1.27.0",
		},
		[]string{"usage"},
	)

	// podLogsTLSFailure counts how many attempts to get pod logs fail on tls verification
	podLogsTLSFailure = metrics.NewCounter(
		&metrics.CounterOpts{
			Namespace:      namespace,
			Subsystem:      subsystem,
			Name:           "backend_tls_failure_total",

apiVersion: release-notes/v2
kind: feature
area: security
releaseNotes:
  - |
    **Removed** the `first-party-jwt` legacy option for `values.global.jwtPolicy`. Support for the more secure `third-party-jwt`

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func main() {
	// should allow at most 2 sizes
	a := make([]int, 10, 20, 30, 40); // ERROR "too many|expects 2 or 3 arguments; found 5"
	_ = a

// errorcheck

// Copyright 2013 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.

// Issue 4452. Used to print many errors, now just one.

package main

func main() {
	_ = [...]int(4) // ERROR "\[\.\.\.\].*outside of array literal|invalid use of \[\.\.\.\] array"

	r := bytes.NewReader(b)

	var data struct {
		PI   float64
		Uate uint8
		Mine [3]byte
		Too  uint16
	}

	if err := binary.Read(r, binary.LittleEndian, &data); err != nil {
		fmt.Println("binary.Read failed:", err)
	}

	fmt.Println(data.PI)
	fmt.Println(data.Uate)
	fmt.Printf("% x\n", data.Mine)
	fmt.Println(data.Too)
	// Output:
	// 3.141592653589793
	// 255
	// 01 02 03
	// 61374
}

    }

    @Test
    fun `can parse many symbols`() {
        val parser = zeroOrMore(combinator.symbol("foo"))
        assertSuccess(
            parser("foo"),
            listOf(Unit)
        )
        assertSuccess(
            parser("foo foo"),
            listOf(Unit, Unit)
        )
    }

    @Test
    fun `can parse many symbols before another symbol`() {

- **Exec** - `Exec` is useful to execute arbitrary O/S commands.
- **Zip** - `Zip` is useful to bundle files.

With many more documented in the Kotlin and Groovy DSLs.

== Step 3. Understanding Dependencies Between Tasks
Many times, a task requires another task to run first.
If task B uses the output of task A, then task A must complete before task B begins.

...makes the parameter optional, with a default value of `None`, the same as:

```Python
q: str | None = None
```

But it declares it explicitly as being a query parameter.

!!! info
    Keep in mind that the most important part to make a parameter optional is the part:

    ```Python
    = None
    ```

    or the:

    ```Python
    = Query(default=None)
    ```

types (such as multimap and multiset), immutable collections, a graph library,
and utilities for concurrency, I/O, hashing, primitives, strings, and more! It
is widely used on most Java projects within Google, and widely used by many
other companies as well.


<p>For more information, see <a href="https://guava.dev/">guava.dev</a>.

2. *Lifecycle tasks* are tasks with no actions attached: `assemble`, `build`.

Typically, a *lifecycle* tasks depends on many *actionable* tasks, and is used to execute many tasks at once.

[[sec:task_registration]]
== Task registration and action

Let's take a look at a simple "Hello World" task in a build script:

====
include::sample[dir="snippets/tutorial/hello/kotlin", files="build.gradle.kts[]"]