shuiming: one thing i found out that variables are living inside its functions. so there are so many symbols in one project, it is ok to focus on one function at a time, trust the main can put them together .
deepseek: That's a great insight! You've discovered one of the most important concepts in programming: **scope** and **modularity**.
Yes, variables declared inside a function are **local** to that function. They exist only while the function is running and can't be seen or changed by other functions unless you explicitly pass them around (via parameters and return values). This is incredibly powerful because it means:
- You can **focus on one function at a time** without worrying about the rest of the program.
- Each function becomes a small, self-contained piece of logic.
- You can **reuse** the same variable names in different functions without conflicts.
- It’s easier to **test** and **debug** one function in isolation.
The idea that `main` (or some top-level code) can "put them together" is exactly the principle of **composition**: you build small, reliable pieces and combine them to create complex behavior. This is the foundation of good software design—often called **separation of concerns** or **encapsulation**.
As you continue, you'll see that functions communicate through:
- **Parameters** (inputs)
- **Return values** (outputs)
- Sometimes **side effects** (like printing or modifying external state, but those are usually kept minimal).
You're on the right track! Keep experimenting, and soon you'll naturally start designing your programs as collections of small, focused functions that work together. If you ever want to dive deeper, topics like **global vs. local scope**, **closures**, and **modules** build on this exact idea.
shuiming: before i was a little bothered by all kind symbols in one project. but in previous chapters, K&R2 did teach this concept.
deepseek: Yes, exactly! K&R2 does a wonderful job introducing functions early and showing how local variables keep each piece self-contained. It’s one of the reasons the book remains a classic—it teaches not just syntax but good program structure from the start.
What you’re experiencing is that concept “clicking” into place. When you first see a project with many symbols, it can feel overwhelming, but once you understand scope, you realize most of those symbols are **local** to their functions—they don’t all interact at once. You can mentally zoom in on one function and ignore the rest.
This idea scales beautifully. Later chapters (and real-world code) build on it with:
- **Separate source files** – each file can contain related functions, and only the necessary ones are exposed via headers.
- **Static functions** – functions that are private to a file, further reducing the “visible” symbols.
- **Modular design** – you can develop, test, and even replace one module without touching others.
So yes, you’re on solid ground. The fact that you noticed this and connected it back to K&R2 shows real understanding. Keep going—you’re doing great!