The reason is that Kotlin DSL was introduced in Gradle 5.0. Older Gradle versions simply ignore Kotlin scripts.
The solution is to use a `groovy` script since it works on all Gradle Versions. 


# Adding new progress event

* project `build-events`
  * `org.gradle.internal.build.event.types` 

    id: context
    attributes:
      label: Context (optional)
      description: |
        How has this issue affected you? What are you trying to accomplish?
        Providing context helps us come up with a solution that is most useful in the real world
    validations:
      required: false
  - type: textarea
    id: steps-to-reproduce
    attributes:
      label: Steps to Reproduce
      description: |

func ChecksumForConfigMap(cm *v1.ConfigMap) string {
	hash := sha256.New()

	// Since maps are not ordered we need to make sure we order them somehow so we'll always get the same checksums
	// for the same config maps. The solution here is to extract the keys into a slice and sort them.
	// Then iterate over that slice to fetch the values to be hashed.
	keys := []string{}
	for key := range cm.Data {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	// This is necessary for heapster to collect monitoring stats from the kubelet
	// until heapster can transition to using the SSL endpoint.
	// TODO(roberthbailey): Remove this once we have a better solution for heapster.
	KubeletReadOnlyPort = 10255
	// KubeletHealthzPort exposes a healthz endpoint from the kubelet.
	// May be overridden by a flag at startup.
	KubeletHealthzPort = 10248

        T6 interface { T5; T5 }
        T7 interface { T6; T6 }
        T8 interface { T7; T7 }
        T9 interface { T8; T8 }

        // TODO(gri) Enable this longer test once we have found a solution
        //           for the incorrect optimization in the validType check
        //           (see TODO in validtype.go).
        // T10 interface { T9; T9 }
        // T11 interface { T10; T10 }

    SolutionFile(TestFile solutionFile) {
        solutionFile.assertIsFile()
        this.file = solutionFile
        assert TextUtil.convertLineSeparators(solutionFile.text, TextUtil.windowsLineSeparator) == solutionFile.text : "Solution file contains non-windows line separators"

        content = TextUtil.normaliseLineSeparators(solutionFile.text)

                        .solution("Provide a public type for @SoftwareType that is the same type as or a supertype of the property type '" + ModelType.of(valueType).getDisplayName() + "'")
                );
            }
        });
    }

    }

    processResources {
        // Add generated sources to the main jar because `src` or any other Gradle distribution does not include them.
        // A more general solution is probably required: https://github.com/gradle/gradle/issues/21114
        from(apiExtensionsFileCollection)
    }

// -- Version manifest properties --------------------------------------

// limitations under the License.

[[writing_plugins]]
= Writing Plugins

If Gradle or the Gradle community does not offer the specific capabilities your project needs, creating your own plugin could be a solution.

Additionally, if you find yourself duplicating build logic across subprojects and need a better way to organize it, custom plugins can help.

== Custom plugin

    a function of the op for training.

### Use Cases

*   (Portability) User wants to add a new op and run this op on different
    platforms (CPU, TPU, TFLite, etc.) to be portable.

    *   *Solution*: The user should define the new op as a composition. The ops
        used inside the composition should have support for these platforms.
        These ops can also be composite ops.