Sorry, but can I just check, are you saying this is the alternative as in you SHOULD do this, or are you saying this is the alternative as in you SHOULD NOT do this?
It's just the way you wrote it sounds like you're saying this is the recommended way of developing, which I'm sure is not what you meant.
Also, is winmerge available in .deb/.rpm?
The approach is an alternative, as in: you can do it. I used to work that way before I used version control, and I know I'm not the only one. I definitely prefer the workflow with version control, that's for sure, but some seem not to find it especially compelling when working alone and that is their prerogative.
When you're working on your own, any process is fine, if you are comfortable with it. The object of the exercise is to create useful/interesting/etc. products for people to use/enjoy/etc. - and you'd have a hard time arguing that this is a goal Dwarf Fortress has failed to meet.
(Unsurprisingly, I've yet to meet anybody that's preferred working without source control on shared code. But perhaps they do exist.)
Strong disagree. If you're working on things that are sufficiently complex, you'll not-infrequently find yourself in a situation where the thing you were working on has become broken, and you can't remember how or when it broke.
Single-dev version control lets you make frequent checkpoints so that you can compare the current state to a previous one to discover the source of and quickly recover from failures of the mind such as these.
My git history is littered with one or three word commit messages. If I ever go to publish my code (or finish with what I was doing) then I rebase all that shit into a coherent history. But, until that point I don't spend even a microsecond worrying about attaching meaningful messages to my checkpoint commits.
But to fix an accident? That's what ~5-min ZFS snapshots are for.
git log --patch
to look at your history, combined with git checkout $COMMIT
to get the code to perform any tests required? (Or, if you have a reliable automated test, git bisect start HEAD $KNOWN_GOOD_COMMIT -- && git bisect run $TEST
will automatically find the error for you.) [0][1]And remember that the git checkpoint creation process is -at its most verbose- running
git commit -m "C"
[0] You can use points-in-time as commit references, like 'master@{30 minutes ago}' or 'HEAD@{2016-01-01}'[1] And even if you don't have a test, you can easily manually run the bisect machinery.
At university the lab systems had a networked home directory setup, and one of the greatest things was a '/yesterday/' link to your personal homedir, exactly as it was 1 day ago.
I have no idea how they set it up, but something along these lines is plausible.
My 'backups' may as well be a cronned:
git add . && git commit -m "Daily snapshot" && git push
Ta-da! You are now 'using' source control.This or any other automatic backup solution has a big problem though: if the backup happens while you have a syntax error or something in your code then your test suite will fail and any bisect type functionality you have will be useless.
I would recommend learning git for anyone. Sure, it's a big hassle, because it forces you to rethink your habits. But in the end, learning it has done me nothing but good and using it enforces me to follow good practice at the same time.
Also, just the support of 'git stash' to throw away experiments that didn't work easily is worth it. Tagging versions for release, demos, whatever .. git can help there too.
It doesn't. Nothing prevents you from adding/committing several days worth of work with a "changed stuff. fixed some other stuff" commit message.
If people have good reasons for not doing certain things, then fine, but when people are just averse to it because they're lazy, well, that irks me (when I have to deal with them.)
I didn't speak up about it because I was only a contractor at the time, but it made me wince to see a whole history list of his commits with like 20 "latest and greatest" and maybe three commits that actually said what he did.
But most places I've been to, people have been pretty good about explaining what they've committed, when version control was being used.
git log --pretty=oneline --abbrev-commit --graph --stat
Seeing the names of the changed files in each commit gives me a lot more of context than simply the commit description.
At my current job we have dev tasks associated with the changesets (if applicable), so that helps provide context also.
If and only if you're a solo developer working on a single computer and work on a pretty linear, one feature at a time development.
And if you're a solo dev, you won't need to "waste" a lot of time in version control anyway. All you need is "git init", "git add" and "git commit" and you're already better off than without. Anything on top of that is optional but useful.
What it is:
git commit -am '(what changed)'
Effortless combination of history, backup, and publishing. There’s very little reason not to do it. Up to preference how often it’s done and how detailed messages are.And of course with even one other developer working on the same code base I'd say VC is practically mandatory.
If you save a copy of your code each day, you are using version control - just an ad-hoc, error-prone sort of version control that wastes space and makes it painful to do any of the things people use version control for.
If you know your project is for sure _personal_ (i.e. not shared) and a small _proof-of-concept_ (i.e. if you go further in that direction you will do a rewrite anyway), I think it is overkill. Your code and data will be in so much flux, that good old copying is faster than dealing with the VC.
Thinking about it, I think it makes sense to add VC to a project, when it delivers its first satisfying result, I would call that the proof-of-concept program. At that point you throw it away/archive it, or you have bigger plans, then you probably add version control knowing you have this working prototype and rewriting stuff.
You do not have the history to that point, but it would not be helpful anyway.
You waste more time picking your nose.
Easy branching and merging enable exploratory programming in a way that makes you stop worrying about a whole class of regression bugs forever.