Downloading and installing the package dependencies **could take minutes**, but using the **cache** would **take seconds** at most.

And as you would be building the container image again and again during development to check that your code changes are working, there's a lot of accumulated time this would save.

* Groovy strings can be quoted with single quotes `'string'` or double quotes `"string"` whereas Kotlin requires double quotes `"string"`.
* Groovy allows to omit parentheses when invoking functions whereas Kotlin always requires the parentheses.
* The Gradle Groovy DSL allows to omit the `=` assignment operator when assigning properties whereas Kotlin always requires the assignment operator.

    ...
```

But right at the moment Python compares the first `j` in `johndoe` to the first `s` in `stanleyjobson`, it will return `False`, because it already knows that those two strings are not the same, thinking that "there's no need to waste more computation comparing the rest of the letters". And your application will say "Incorrect username or password".

But then the attackers try with username `stanleyjobsox` and password `love123`.

// FunctionDef corresponds to a single ConcreteFunction.
// 2. A tf.function can take arbitrary python inputs, whereas the FunctionDef
// only accepts tensors.
// 3. A tf.function is a closure that can contain captured inputs, whereas
// FunctionDefs loaded from SavedModels are "functional" (all inputs are
// explicitly passed as arguments).

 5. It sends the HTTP request and reads the response.

func _() {
	// P can be inferred as there's a single specific type and no tilde.
	var _ chan int = ch1 /* ERRORx `cannot use ch1.*value of type chan<- int` */ ()
	var _ chan<- int = ch1()

	// P cannot be inferred as there's a tilde.
	ch2 /* ERROR "cannot infer P" */ ()
	type myChan chan int
	ch2[myChan]()

	// P can be inferred as there's a single specific type and no tilde.
	var e int
	ch3(e)

                // Note: throw the failure rather than returning a result object containing the failure, as console failure logging based on the _result_ happens down in the root build scope
                // whereas console failure logging based on the _thrown exception_ happens up outside session scope. It would be better to refactor so that a result can be returned from here
                throw UncheckedException.throwAsUncheckedException(t);

                // Note: throw the failure rather than returning a result object containing the failure, as console failure logging based on the _result_ happens down in the root build scope
                // whereas console failure logging based on the _thrown exception_ happens up outside session scope. It would be better to refactor so that a result can be returned from here
                throw UncheckedException.throwAsUncheckedException(t);

go list -e -f '{{range .Imports}}{{.}} {{end}}' ./p
stdout '^fmt '

# 'go list' should report the position of the error if there's only one.
go list -e -f '{{.Error.Pos}} => {{.Error.Err}}' ./p
stdout 'b.go:[0-9:]+ => expected ''package'', found ''EOF'''

# 'go test' should report the position of the error if there's only one.
go list -e -test -f '{{if .Error}}{{.Error.Pos}} => {{.Error.Err}}{{end}}' ./t

name: "Notify Translations"
description: "Notify in the issue for a translation when there's a new PR available"
author: "Sebastián Ramírez <******@****.***>"
inputs:
  token:
    description: 'Token, to read the GitHub API. Can be passed in using {{ secrets.GITHUB_TOKEN }}'
    required: true
runs:
  using: 'docker'