Course outline

01 · Getting Started6/6

02 · Variables, Types & Control Flow6/6

03 · Functions & Composite Types6/6

04 · Methods, Interfaces & Errors6/6

05 · Packages, Modules & Concurrency Intro6/6

06 · Your First Real Program6/6

07 · Testing & Debugging in Go6/6

08 · Capstone — Ship a Real Tool7/7

09 · Generics6/6

10 · Concurrency in Practice6/6

11 · Language Depth II6/6

12 · Standard Library Toolkit6/6

13 · Building Web Services6/6

14 · Working with Databases6/6

15 · Advanced Runtime & Tooling6/6

16 · Building a Terminal Dashboard with Bubble Tea5/5

17 · Closing the Loop2/2

Stage 1 · Code

Standard Library Toolkit

Move Through Files Without Tripping

Small files let you get away with blunt tools. Real programs need buffered reading, buffered writing, portable paths, and a way to walk directory trees without turning memory into a dumping ground.

15 min readThe Complete Go EngineerCode

Why Buffering Exists

Reading from a file is not like reading from a normal Go variable. Each trip to the operating system costs work. If your program asks for one tiny piece at a time, the CPU spends too much time knocking on the OS door.

A buffer is a staging tray. Instead of making a fresh system call for every byte or every short line, Go pulls in a larger chunk once, then serves your code from that in-memory tray until it empties. Fewer system calls usually means less overhead and better performance.

Tool	Good fit	What it helps with
`bufio.Scanner`	Simple line-by-line or token-by-token reading	Convenient loop-based input processing
`bufio.Reader`	More control over reads	Reading strings, bytes, or chunks with custom boundaries
`bufio.Writer`	Many small writes	Fewer flushes to the operating system

Gobuffered-reading-and-buffered-writing.go

39 linesLn 1, Col 1Go

The writer keeps your small writes in memory until `Flush` pushes them out. Forgetting to flush is like writing notes on a whiteboard and never copying them into the notebook.

Buffered writers do not finish themselves

If you create a bufio.Writer, flush it before you consider the work done. Closing the file does not excuse you from that responsibility in the code you write.

Reading Large Files Safely

For a tiny config file, os.ReadFile is perfectly fine. For a giant log, it is like dragging an entire filing cabinet onto your desk because you wanted one page at a time. Streaming is calmer. You inspect one piece, do your work, then move on.

Goscanning-a-multi-line-file-token-by-token.go

29 linesLn 1, Col 1Go

This is the key streaming idea: read one token, process one token, forget one token, repeat. Your memory use stays steady even when the input grows.

Goreading-a-large-file-line-by-line.go

30 linesLn 1, Col 1Go

The program never stores the entire file in memory. It sees one line at a time, which is exactly what you want for large inputs.

Building Portable Paths

File paths are not just strings with slashes thrown in. Different operating systems use different separators and different conventions. path/filepath exists so you do not have to hand-build those rules yourself.

Gousing-`filepath`-instead-of-manual-string-building.go

18 linesLn 1, Col 1Go

`filepath.Join` chooses the correct separator for the current OS. That means one source file can behave correctly on macOS, Linux, and Windows.

Use `path` for slash-separated URLs, `filepath` for local filesystem paths

They sound similar because they solve related problems, but they are not interchangeable. Local files should normally go through path/filepath.

Walking Directory Trees

Sometimes the program does not know the exact file names in advance. It only knows a starting directory and a rule such as 'visit every .json file'. filepath.WalkDir gives you a structured way to do that.

Gofinding-every-`.json`-file-below-a-root-directory.go

34 linesLn 1, Col 1Go

`WalkDir` calls your function for each directory and file it encounters. Returning `filepath.SkipDir` is how you politely say 'ignore this subtree and move on.'

Quiz

Quiz & Practice

Question 1 / 3

Why does buffered I/O often improve performance?

Practice

Count Non-Empty LinesEasy

Write a function `CountNonEmptyLines(text string) int` that uses a scanner to count lines that are not empty after trimming surrounding spaces.

Gosolution.go

Summary

Buffers improve I/O efficiency by reducing how often your code has to call into the operating system.
bufio.Scanner is great for simple token or line processing, while Reader and Writer give you more control.
Streaming large files keeps memory use steady because you only process one piece at a time.
path/filepath protects you from hard-coded path separator assumptions.
filepath.WalkDir lets you explore a whole directory tree with one clear callback-based pattern.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.