Explain this code. User is in go mode.

```go
func main() {
	flag.Usage = func() {
		fmt.Printf("%s <file>\n\nprints file to standard out\n", os.Args[0])
	}
	flag.Parse()

	if flag.NArg() != 1 {
		log.Fatalf("wanted 1 arg, got %#v", os.Args)
	}

	fin, err := os.Open(flag.Arg(0))
	if err != nil {
		log.Fatal(err)
	}
	defer fin.Close()

	_, err = io.Copy(os.Stdout, fin)
	if err != nil {
		log.Fatal(err)
	}
}
```

This is a Go program that reads a file and prints its contents to
standard output. Here's how it works:

1. The `Usage` function sets the usage string for the program to be
   printed when the program is run with incorrect arguments.
2. `flag.Parse()` parses the command-line arguments and sets the
   values of the corresponding flag variables.
3. `flag.NArg()` returns the number of non-flag arguments.
4. If `flag.NArg()` is not exactly 1, `log.Fatalf()` prints an error
   message and exits the program.
5. `os.Open(flag.Arg(0))` opens the file specified in the first
   non-flag argument.
6. `defer fin.Close()` arranges for the file to be closed after the
   function completes or if there's an error.
7. `io.Copy(os.Stdout, fin)` copies the contents of the file to
   standard output.
8. If there is an error opening the file or copying its contents,
   `log.Fatal(err)` prints an error message and exits the program.

Overall, the program provides a simple command-line interface to read the contents of a file and print it to the console.