Why is the solo spider programmer switching from Dropbox to "real" version control?
I am a relatively inexperienced (recently graduated) web designer who writes HTML and JavaScript a lot and also works with large Photoshop files. I've gotten used to the fact that the files I'm working on are in the Dropbox folder due to Dropbox's excellent history feature. If I make a serious mistake, I can always revert to a previous version of any file.
The prevailing opinion on StackExchange seems to be that Dropbox is much better than nothing, but still not as good as a "real" version control system like Git. But for a solo web designer, I feel like Dropbox provides the best source control benefits (never lose your job) without its downsides (learning curve, maintenance).
Being able to unlock my code doesn't seem valuable enough to me to justify
- learning a new system and
- observing a "commit" of changes every time I make a significant change.
If I collaborated with others on this stuff, it probably would change, but it's just me here. And working with Dropbox is effortless; keeping my work safe requires no extra effort other than keeping it safe.
I want to follow industry best practices, and if there is an important feature that I am missing, I would like to know what it is. How important is a version control system to a solo programmer that balances the increased overhead relative to Dropbox?
source to share
VCS is about more than keeping your files safe!
When you're working alone, it's easy to make changes as you go. You have a codebase that is managed and you are only interested in the most recent snapshot of your code. This is especially important when you are developing websites where users are always represented by the newest version.
This mentality can be unhealthy! Imagine delivering some version (possibly binary) to a customer, but keep working on it. When a client comes back to ask for changes, how can you easily understand what changes have been made since the client version? What if you have since made significant changes that the client is not interested in. With Dropbox, you only have 30 days of clutter in your story. With git, things like committing logs and branches allow you to easily work and manage different versions of your code without hesitating to copy folders, leaving notes around and what you have.
More importantly, if you start collaborating with someone, you may come back from vacation and a lot of changes have been made to the software. You just look at the commit log to see what changed. With dropbox, these are just file changes, not separate units of explainable updates made to the project, as is the case with VCS.
You can also start working on a big new feature or just try something in your codebase. With a new branch, you can hack that branch while you (and others) continue working on the stable branch. You might want to incorporate the changes you made to the stable branch into your feature branch (merge), but you can sleep at night because you know that your incomplete feature branch does not interfere with working on the stable branch.
The main thing is not that VCS has features that are better than Dropbox - it is that you should think of VCS when you write code. You improve your app one feature at a time, and you can explain and justify each of them - don't just make changes as you go ahead, forgetting about the hawas and what they want.
When you start using VCS for yourself, you will most likely find that you end up forgetting about it and committing at the end of the day, leaving "some files added, some changes made" as a commit message. In this case, VCS is no better than Dropbox. But if you stick to good etiquette, make short commit messages often, even a simple repository with one master branch and version tagging will automatically do much, much better than a dropbox. As you grow with VCS, you'll probably start using other features like branching, and you'll wonder how you've ever done it with Dropbox.
For an example of a good git tag, consider the git stream branching model . I personally think this is a great and easy way to use git alongside Sourcetree , but there are more ways to use git than there are atoms in this universe - just make sure you find the one that works for you :-)
source to share
Some of the benefits of working with VCS are as follows:
- It's easy to demarcate your code, see what changes you've made.
- Determine why certain changes were made - often when you commit changes, you also add the reason for those changes. This might be useful in the future (for example, it fixes a strange problem with IE 7, etc.).
- If you ever want to collaborate with someone or give them access to your code, they have access not only to the code itself, but to its entire history.
- Most tags and branches support VCS. This makes it easy to find specific versions of your code and allows you to investigate different solutions to problems while keeping a copy of the code that matches the deployment.
Finally, learning CVS like git is always useful from a busy point of view.
Not sure how useful a source control system can be for photoshop files, but for code it's great if you need any of the above.
source to share