Operating System Access

A bufio.Writer holds bytes in memory until its buffer fills, so whatever is still buffered when the program ends is simply lost. Call Flush before the file is closed, and check the error Flush returns.

io.Copy streams bytes from a source reader to a destination writer through one small reusable buffer, so memory does not grow with the payload. It returns an int64 count of bytes written and the error that stopped the transfer.

io.Reader.Read writes into a byte slice the caller supplies, so the caller decides how much memory a stream costs and can reuse one slice for every call. Returning a fresh slice per read would allocate on every call.

io.ReadAll reads an io.Reader to end of stream and returns every byte in one slice. It takes no size limit, so a sender that keeps sending can grow that slice until the process runs out of memory.

The whence value says what the offset is measured from: io.SeekStart from the beginning of the file, io.SeekCurrent from the position you are at now, io.SeekEnd from the end. Seek returns the new absolute offset.

Overwriting in place leaves the file half-written, so a concurrent reader can load a truncated config. Writing a complete temp file first and calling os.Rename swaps the name in one step: readers see the whole old file or the whole new one.

os.ReadFile opens the named file, reads it to the end, closes it, and returns the whole contents as a []byte together with an error. Reaching end of file is not an error, so a successful read returns a nil error.

os.Stat returns an fs.FileInfo for a named path, plus an error. FileInfo is an interface: Name, Size, Mode, ModTime, IsDir and Sys report the base name, byte size, mode bits, modification time and whether the name is a directory.

os.Open opens an existing file read-only. os.Create creates or truncates a file for read-write with mode 0666. os.OpenFile is the general form behind both: you pass the open flags and the permission bits yourself.

os.ReadDir returns a sorted slice of fs.DirEntry values for one directory plus an error. Each entry gives Name, IsDir and Type; IsDir reports a subdirectory. It reads a single level and never recurses.

filepath.Join separates elements with the platform's own separator, drops empty elements, and cleans the result, so doubled separators and .. segments collapse. Hand-concatenating with a slash yields names like logs//app and emits the wrong separator on Windows.

The //go:embed directive copies the files matching its pattern into the compiled binary at build time. It must sit directly above one package-level variable of type string, []byte, or embed.FS, and the source file must import the embed package.

filepath.Join cleans its result, so ".." elements are resolved rather than rejected: Join("/srv/uploads", "../../etc/passwd") is "/etc/passwd". Join is path arithmetic, not a confinement check, and Clean is not one either.

No. Clean, Rel, Join, Base, Dir and Ext are pure string operations that never open a file or resolve a symbolic link. filepath.Abs is the exception: for a relative input it prepends the process's working directory.

Use path for strings that are slash-separated on every platform: URL paths, archive entry names, slash-separated keys. Use path/filepath only for names you hand to the operating system, because it follows the local separator and understands Windows volume names.

Read the variable with os.LookupEnv before flag.Parse and pass its value as the default argument when you declare the flag. flag.Parse then overwrites that default only for flags that actually appeared on the command line.

os.Getenv returns only the value, so an unset variable and one set to the empty string both come back as "". os.LookupEnv returns the value plus a presence boolean, keeping those two cases distinct.

flag.String registers a flag before the command line has been read, so it can only hand back a pointer to storage it will fill in later. Call flag.Parse() first, then read the value as *ptr.

Give each subcommand its own *flag.FlagSet from flag.NewFlagSet, switch on os.Args[1] to choose one, and call that set's Parse on os.Args[2:]. Each set owns its own flag names, usage text and operands.

The working directory is one attribute of the whole process, not something each goroutine owns. os.Chdir changes how every relative path in the program resolves, including paths other goroutines are opening at that instant.

By default it kills the child outright with os.Process.Kill, which is SIGKILL on Unix, as soon as the context is done. No graceful signal, no grace period, and the program must still call cmd.Wait.

exec.Command starts the program directly through the operating system, with no shell involved. Every string after the program name becomes one exact argument, so ls receives the four characters *.go as text. Globbing, pipes, redirection and variable expansion are shell features.

Run just waits for the child and sends its output wherever Cmd.Stdout and Cmd.Stderr point, discarding it if they are nil. Output returns stdout as bytes. CombinedOutput returns stdout and stderr interleaved in one byte slice.

cmd.Wait closes the pipes it created once the child exits, so unfinished reads lose whatever was still in flight and then fail against a closed file. Read the pipe to end of file first, then call cmd.Wait.

Use cmd.StdoutPipe when you must stream output as it arrives, or when the output is too large to hold in memory. Assigning a bytes.Buffer to cmd.Stdout is simpler: os/exec drains the child for you.

Call signal.Notify with a buffered os.Signal channel listing os.Interrupt. Go then delivers Ctrl-C on that channel instead of terminating the process, so your code decides what happens next. signal.NotifyContext does the same registration and cancels a context.

os.Exit ends the process immediately at the runtime level without unwinding any goroutine's stack, so no deferred call anywhere runs. Whatever a deferred flush, close, cleanup or summary would have done simply never happens.

Cancellation flows from parent to child. A context derived from an already-cancelled parent is born cancelled: its Done channel is closed at once and its Err is context.Canceled, not context.DeadlineExceeded. Parent the budget on a live context.

When main returns, the Go runtime ends the process with status 0, which every caller reads as success. To report failure you must call os.Exit with a non-zero code; os.Exit(1) is the conventional failure status.

The platform that sent the stop signal kills the process after a fixed grace period anyway. A bounded wait finishes what it can and then reports what it abandoned; an unbounded wait hands that decision to a kill instead.