Keeping track of interdependent changes as a selling point for git over word processor trackchanges

[katrinabrock]

How could the content be improved?

IMO one of the main things git does well that is harder to do with other GUI version control (e.g. word/google doc track changes) is allow you to work in a sandbox, putting together a set of changes where each change in isolation could break the project but together, they are an improvement.

It's easy to contrive an example of this with code such as renaming a function. If you rename a function only in the definition, the entire program will probably break. You need to make many changes throughout the program renaming it everywhere and all these changes need to be introduced together to in order for the program as a whole to work both before and after. Accomplishing this would be difficult or impossible with word-processor style comments suggesting changes because each change is isolated. This functionality is absolutely essential to software projects.

I would be nice to concisely (maybe visually?) summarize this advantage of git in episode 1. I think it would be possible, to come up with an example in the recipe context.

Which part of the content does your suggestion apply to?

Automated Version Control

[erinmgraham]

Thanks for raising this! You make a great point about one of Git’s strengths. At the same time, many learners are new to version control and adding a detailed example of multi-step changes (like renaming a function across a codebase) might risk cognitive overload early on.

I’d love to hear what others think:

• does this suggestion add sufficient value to include in the lesson
• should we keep the intro simple and defer this concept to later episode, eg ep 04 where we talk about committing multiple files, or include it in ep01?

If you have a concrete example in mind, feel free to open a PR or share a draft here—that might help us visualize how it could fit.

Thanks again for the thoughtful feedback,

[katrinabrock]

An example with recipes might be adding an item to an ingredient list and adding the processing instructions. e.g.

 ## Ingredients
 * avocado
+ * onion
 * lemon
 * salt
 ## Instructions
+ Dice the onion.
 Smash the avocado.
- Squeeze in the lemon, sprinkle in the salt and mix. 
+ Add the diced onion to the avocado.
+ Squeeze in the lemon.
+ Sprinkle in salt and mix.

Above has 3 changes. Word processor "suggestions" would treat these as separate suggestions, but the recipe wouldn't make sense if you accept 1-2 of them but not all 3.

[erinmgraham]

Thanks for sharing this example—it’s a great illustration of why atomic commits matter. I do worry that introducing this concept in Episode 1, before they’ve mastered single commits, might be too advanced for beginners.

In Episode 4 there is a Challenge Committing Multiple Files that demonstrates the same principle—grouping related changes into one commit—using multiple files rather than multiple changes in the same file.

I think the simplest way to incorporate your point is to add a sentence to this challenge, e.g.:
“This is something word processors can’t easily do—grouping related edits into one logical change. In Git, you can bundle multiple updates that belong together so your project stays consistent.”

That way, we reinforce Git’s advantage without overwhelming learners early on. Would you be happy with that approach?

[katrinabrock]

I like the wording!

[erinmgraham]

haha, I like your comment! let's wait to hear what other folks say :-)

[martinosorb]

Sounds good as you said, erin.