You (not you specifically theamk, but others who might be interested in the _why_ of rebasing/amending is not in Fossil) can read more about it here: https://www.fossil-scm.org/xfer/doc/trunk/www/rebaseharm.md
> Git lets a developer write a feature in ten check-ins but collapse it down to an eleventh check-in and then deliberately push only that final collapsed check-in to the parent repo
> Fossil pushes all 11 check-ins to the parent repository by default, so that someone doing that bisect sees the complete check-in history, so the bisect will point them at the single original check-in that caused the problem.
And I think: Well, it'll work if you are drh.. I know if I were in this situation, commit 3 is broken because I forgot to run tests, commit 5 would not even compile because I made it just before going home, and the main app would not even work until commit 8 because I focused on the unit tests..
My non-final commits are messy. I don't want to inflict them on people.
- committing code at the end of the day
- making a temporary commit in order to checkout to another branch to work on things, etc
- committing code in order to pull onto another computer (admittedly a bit lazy, but I do this for small personal projects)
- fixing a commit that accidentally checked in binary files, secrets, etc. it happens!
I find myself checking out to different branches frequently to look at something for a colleague. I would much rather make a temporary commit to later rebase instead of using git stash.
Reading about fossil evokes a little bit of "you're holding the phone wrong", in my opinion. Git does lack things like issue trackers but I would rather not be limited by own tooling for little gain.
That's a Git bug.
They choose not to use it, for some reason (since they know about it, from their comment).
But sure, I'll grant you that it has issues. Heck, Git is distributed, so if you're off-network, committing a bunch of code, and your computer breaks, it doesn't matter if you're using stash or commit. It all depends upon your use case.
You're not OP, but if they, needing to switch to a different branch for a bit, "would much rather make a temporary commit to later rebase instead of using git stash" I'm curious why. I know I used to do it because I didn't understand how stash worked, and then I read up on it, noted what the commands are in my listing (since I don't need to use it daily), and refresh my memory from my notes when I need to use it.
But I also prefer to do smaller commits, more often, and find history to be important. Likely because I do a lot of brownfield development and maintenance. And if I need to switch to another branch to help a colleague, and my code is such that I can't commit it yet, I'll either git clone to a new directory (if they're a new employee or someone just learning a project, and I know I'm going to be helping them a lot) or leverage git stash.
A second, equally important step is to adopt tools and methods which allow the appropriate amount of build and test for your team. If you insist on full continuous-integration and an always-working master branch, you had better make sure people can run build-and-test cycles from a working copy, prior to any commit. On the other hand, if you have focused on automated build-and-test being driven by commits, you had better adopt an appropriate branch and merge strategy to tolerate the fact that untested things are going to be committed as a regular event!
With git, I think the disconnect people have is that you should not be rebasing or amending history that you have already shared. Someone following along in a shared repo should never have the rug pulled out from them, putting their own tools into a broken state. I would much rather see an uglier commit history than feel like I am being gaslit by transient errors and here-today, gone-tomorrow commits. Depending on your exact tools, sharing might mean pushes to the central repo or everything in your own self-hosted repo that you allow others to see, even read-only.
If using a sharing model like github, that means you could feel free to rebase or amend only the batch of changes since your last push to upstream. Nobody looks at your own local clone of the repo. Every push should monotonically move the history forward in a way that all observers will see the same way. I wouldn't care if you amended commits before you pushed them, since I could never see the earlier drafts. I also would not care if there are some buggy commits in your personal working branch, as long as you address them with further commits before attempting a pull request or other merge to a shared integration branch. But, I should never be able to pull twice in any available branch and face a bizarre merge-conflict because you amended something in between my pulls.
Also, many teams can benefit from earlier sharing to avoid different private efforts from diverging too far and creating larger integration headaches or dead ends. Seeing individual commits that expose developer thought process can also help with communicating new ideas or identifying potential problems. Large rebases can interfere with this. Some organizations also will find it easier to do disaster mitigation if they know that all work products are pushed regularly (e.g. daily) to a shared repository, rather than having to worry about many distributed repos holding sole copies of new work. Such shared, periodic snapshots put an upper bound on how much work product you might be able to amend/rebase without sharing.
- A - B - C - D --o
\-------ABCD -/
Where D == ABCD.- Describe the immutable history of work done on the project by individual programmers. ("Then I fixed X but broke Y", "then I fixed Y", "then I committed before going home")
- Describe the semantic history of features / bug fixes. ("Merge feature X", "Fix bug Y", "Refactor feature Z")
Both of these logs of history are valuable, and git commits conflate both of these ideas to the detriment of users. The natural affordances of git seem to push you toward seeing commits as simply logging history, but having a history of features & fixes is more useful. (Because of git bisect, and it makes git log more useful, and so on). But throwing away all that information about what actually happened seems unnecessarily lossy to me. Its like we're trying to paint a revisionist history of our work. And retroactively modifying commits with rebase and so on works against a lot of git's other design assumptions - like commits being content-addressable)
I wish there were ways of flagging commits as "oh and by the way, this commit isn't just me committing for convenience. This commit merges feature X into the project. We've run all the unit tests. If you run git bisect, use this sha but not the others. Whitelist this sha in git log by default."
I agree about not changing published history. But you don't need Fossil for that -- gitlab, github and even vanilla git all have ways to make master branch "fast-forward-only", which eliminates this problem. And if you are worried about "here-today, gone-tomorrow commits", git has a per-branch flag to prevent rebases and warn you loudly about them.
I agree that working in the open is good, but again, there is no need for Fossil for that -- that's what "sandbox" branches are for. As long as you don't push incomplete work to master, you can share it easily.
Couldn't you make a new history branch, copy/paste as needed from the original one, and just abandon the old history?
That's effectively what git does under the hood anyway - all your shas are changed, but the old ones are left around. If you haven't named (branch/tag) them, you just don't see them normally, and they may eventually get garbage collected.
In a version control system, this is axiom 0.
Unless you want to get really semantic in which case, sure "history" can't be changed, but "recorded history" certainly can.
It is a huge blob of changes. When it will be ready, I'd have to split it to maybe 6 to 8 commits, with well written commit messages. But I cannot do this yet -- for all that I know, I'll find out my design was bad, and I'll have to change those things tomorrow.
So the question is: what do I do with it?
In the old days, I had a VCS which could not change history (SVN). So I'd keep multiple worktrees and back them up manually ("project-2009-12-03.tar.gz", "file1.cc.before-refactor") and so on. The data would be lost sometimes. It was a pain generally.
Now, I have a git branch. It has commit messages like "fix crash in Foo()", "what if we used trie?", "oops forgot to update Bar to match" and so on. They should never see the light of day, and they won't -- they'll get re-made into different commits later. And git will help me to make sure the changes are not lost.
It looks like with the fossil, I should be going back to multiple worktrees and manual backups. I don't understand why would one want to do so.
In rebase world, I have a cycle of "cherry-pick a few changes, get them into master, rebase experimental so it gets smaller; repeat until nothing is left of experimental"
In permanent world, I guess I have two worktrees and copy files one-by-one, manually?
The question is, why would people give this up and move to Fossil?
It seems like both "an immutable view of what happened" and "a crafted narrative of feature changes, bug fixes and releases" are useful. Its ridiculous that I'm expected to pick one. Git and fossil should raise their game.
(Yes; git's tooling supports either approach, but not both at the same time. A better tool would let me avoid making this tradeoff at all.)
I don't use that axiom, rampantly alter history all the time, and Fossil is not for me.
I'm glad that person mentioned it.
I honestly think that commit very often is overrated. It really ought to be save and back up your files very often.
When I implement something, I don't bother making commits until I have completed the features. I then take the diff against the code and then selectively stage parts of the diff and make commits out of them.
If someone else wants to see what was done so far, I just send them the diff as it is.
Git is the backup.
But semi-automatic backups, a.k.a. frequent git commits, are very helpful. For me, three-word commit messages like “no longer segfaults” or “will try sets” are exactly what I need, as they easily let me find out what exactly did I do so it segfaults again, or to revert code a bit if it turns out the sets are not a great idea.
Of course no one else, including me, would care about this once the feature is done, and that’s where rebase comes in.
If you're going to end up squashing all those in progress commits down to a single commit, then that will work. If you're going to try to make several logical commits, then it becomes a bit more difficult (unless you just take the diff from the original branch and start over on a new branch).
I actually find that using the multi-level undo feature in my editor sufficient for trying out small changes to see if they work or not. That is, if I get to a point where I can't figure out what I messed up, I can simply run something like :earlier 5m to go back to what the state was 5 minutes ago and get back to a working state.