Keep Your Experiments Separate
jessitron.com
jessitron.com
By using a single timeline, where features slowly come together while not being complete, you can see how they interact together since the beginning, which might be crucial to their development.
I think the ideal is a mixture of both strategies, a single timeline where working increments are added, and different timelines that exist only to work on small changes that are eventually joined (even if not complete! they just need to "work").
The stuff I work on is mostly trivial except for the complexity and feature interaction involved in real apps.
At most, there might be one or two interesting problems that can be isolated... but usually not.
If I'm learning a new framework, all the features individually are a 10 minute google search. I'll forget how to use them, but IDE autocomplete will remind me.
I'm not that interested in memorizing 1000 function signatures. I'll learn them in a year of actually using them, if I in fact actually ever use them.
What I'm interested in is how you manage complexity with that framework, and I want to be sure I exercise all the features you only need in larger apps.
I could see keeping experiments separate as being good if you are trying to learn how to build small software. If you plan to do microservices, or you work on a lot of interesting problems that aren't just assembling trivial things, or you just enjoy small and light things.
I guess if the goal is strictly learning and experimenting, forking makes sense. But that requires an expectation from the start that the project will be scrapped at some point. That each version exists as an exercise and will be discarded afterwards. And that can be a great way to learn; I don't mean to sound like I'm discouraging the idea.
But if there's any intention or hope of making something bigger than the sum of its parts, utilizing it yourself in the future or intending to provide it to others, a flow where you can keep things separate but also bring them together with ease seems more optimal. But I guess learning that will be a forked experience its own right.
I don't know the author or Eric, but I'm speculating they are hobby game devs using Unity and GitHub and they're not very experienced with Git.
It may be that Eric wants the projects in separate folders without using `git checkout` to switch between them.
But you can do that more easily by cloning the repo within your own system.
Forking is to be understood conceptually, not as a terminology of any specific version control system. As in a git branch represents a fork in the time-line of the evolution of a code-base. It just happens to be that fork also means something more specific in case of the GitHub/GitLab online services.
Don't base code on something you are going to throw away, stems logically from actually believing that you are "making one to throw away".
"make one with decent tests" is the next lesson to grok. If you are going to throw it away, you will benefit from the tests immediately.
The point of the article is avoiding feature interaction. Try to implement a feature first on top of a smaller feature set first, just so you can learn about the problem domain and the solution space. After that, integrating such a feature on top of a more complete application should be significantly easier.