Go and Versioning: Minimal Version Selection

It may help if you decouple the goal (increased readability of code) and the action (application of a style to code). Pretty printers—and gofmt—apply a style to code. That is their only job; in a traditional pretty printer, you could configure a terrifyingly awful style of code, and it would apply it happily and correctly. The readability of that style is a subjective judgment to others, but this is in no way a concern of the pretty printer.

You may not like the style of code that Go uses. That is a perfectly valid viewpoint, and I encourage you to develop it as you see fit! It is also perfectly valid to criticize the style choice of having an undefined maximum line width.

The problem gofmt solves is not "how do we allow you to style Go code", but more specifically, the problem it solves is "how do we encourage the community to adhere to one style of code for Go?" And it is successful in that. It is obviously unsuccessful in applying a style that you find aesthetically pleasing—alas!

Also, I am afraid that I did not claim indent does not allow for a maximum line width! I said that indent (like other pretty printers) allowed you to define a style "with a specific indent level" and that "you could mix in your own preference for indent level".

A typical pretty printer has knobs and dials to control its output, for instance — gofmt has none.

Though, Python does do a better job than many languages of providing style guidance (pep 8 iirc), and I don't really see people do wacky stuff like messing with where to put space around parens. &c.

Can't speak to Fortran.

Thinking about it, maybe languages like J or APL are always consistently formatted by being so dense there's no room for extraneous formatting?

But certainly for C-like languages I've used, just getting people on the same team to all use the same format was a struggle, much less the whole company, much much less the whole world.

So in that way, gofmt definitely feels revolutionary to me.

I disagree on that - it makes it much easier to share code and to use code from other teams, and removes a whole area which people waste a lot of time on (bikeshedding formatting issues).

Let's say I have this program (which was goformatted):

    package main

    import (
        "fmt"
    )

    // commenting...
    // commenting...

    func main() {
        fmt.Println("hello", "world")
        fmt.Println(
            "hello",
            "world",
        )
    }

    package main

    import (
        "fmt"
    )

    // commenting...
    // commenting...

    func main() {
        fmt.Println("hello", "world")
        fmt.Println(
            "hello",
            "world",
        )
        log.Print("test")
    }

    package main

    import (
        "fmt"
        "log"
    )

    // commenting...
    // commenting...

    func main() {
        fmt.Println("hello", "world")
        fmt.Println(
            "hello",
            "world",
        )
        log.Print("test")
    }

Might well be totally irrelevant here.

Sadly I don't know Rust (yet!), but Cargo certainly seems widely loved and admired.

Perusing the resolver code was pleasant, and impressive. We've come a long way from when you'd pull back the covers on a C++ std library or (god help you) boost, and run away screaming in terror.

The future is bright!