I think you mean Hungarian notation.

In terms of the name in the example, GMin, I think it makes more sense in context. The authors begin with an example of what you would have written in Go before 1.18.

func Min(x, y float64) float64 {
    if x < y {
        return x
    }
    return y
}

Then they introduce the idea of generic functions, but at this point, they’ve just used the name Min for the non-generic function. Hence, they use GMin to clearly indicate the different function.

I think the authors put type inference later for several reasons. First, Go can’t always infer the types, and the rules for when inference is or is not supported are complicated. So, it makes sense to present explicit type arguments initially. As a Go programmer, you are likely to need explicit type arguments sometimes, and I don’t think they’ll ever hurt. (They are like parentheses to specify the order of operations: you should use them if the expression would be less clear without them.) Second, programmers from dynamic languages may assume that generics mean that Go allows you to just slap any or constraints.Ordered into a function definition and then, well, do anything. It doesn’t. The programmer still has to pick a single type for both parameters of GMin. That is, the following won’t work, but someone could easily think it might. Such a person might reason, “Each of a and b are members of constraints.Ordered, so they satisfy the type declaration.” (In the spirit of full disclosure, when I first heard about Go including generics, I thought code like that below would work.)

import (
	"fmt"

	"golang.org/x/exp/constraints"
)

func main() {
	var a int = 10
	var b float64 = 11
	fmt.Printf("min of %v and %v = %v\n", a, b, GMin(a, b))
}

func GMin[T constraints.Ordered](x, y T) T {
	if x < y {
		return x
	}
	return y
}

Anyhow, I don’t mean to say that the tutorial is perfect, but I think the sequence makes good sense, especially for people who aren’t used to generics in other languages or who previously only worked in languages with dynamic typing and few constraints.

For people unfamiliar with generics, I think it makes sense to make obvious the fact that generic functions are literally just regular functions that also take types as parameters. To that end, I appreciate how they worked up to type inference instead of starting there. It makes the whole thing seem more familiar and less magical. I agree that, for people who are already familiar with generics, it probably seems a little silly.

It’s only because it’s presenting the stdlib function called Min at the exact same time, and it makes more sense to give the new one a new name for the sake of discourse than to “rename” the old one.