Approximating square root (loops and functions exercise) Just looking for some feedback on my solution for Tour of Go Exercise 24 - Loops and Functions. Is there anything that looks like a wrong way to do things in go? anything I could have done better?

package main

import (
    "fmt"
    "math"
)

func Approx(x float64, z float64) float64 {

    return z - (((z * z) - x) / (2 * z))

}

func Sqrt(x float64) float64 {

    previous := 0.0
    delta := 1.0
    z := x

    for delta &gt; 0.005 {

        z = Approx(x, z)

        if previous &gt; 0.0 {
            delta = previous - z
        }

        previous = z
    }

    return z

}

func main() {

    for i := 1; i &lt; 11; i++ {

        value := float64(i)

        fmt.Println("Calculating Sqrt for ", value)

        real := math.Sqrt(value)
        approx := Sqrt(value)

        fmt.Println("Real ", real)
        fmt.Println("Approx ", approx)

    }

}
One tiny thing: If you drop one set of parentheses:

return z - ((z * z - x) / (2 * z))


and then run go fmt, it will change it to

return z - ((z*z - x) / (2 * z))


The expressions around the * are close to the * and the expressions around the - are spaced out. In other words, go fmt implies the correct precedence.

Also, using line breaks to separate "sections" of a function is good, but there's no need to add an extra linebreak at the very beginning of a function or just before a }.