From Git to Fossil (2025)
lucio.albenga.es
lucio.albenga.es
I really love the idea of a powerful, shrink-wrapped scm + ticketing etc. system, and I'm a sqlite fan, but fossil hasn't worked out for me.
The argument made by the Fossil project, AFAIU, is that it has a better log view than git and has better traceability through SQL based search in addition t the cli and web interface.
What kind of note are you using? There are several and, if I recall correctly, that affects the view a bit. See the "Auxiliary notes attached to check-ins or branches" https://fossil-scm.org/home/doc/trunk/www/wikitheory.wiki
To me, associating a wiki page to a commit makes way more sense than as a commit message that's part of the commit. This way the message can give a summary and then the detail is given in full-fledged markup file that has its own version history.
Totally fair if that's not something that works for you, though.
And honestly, I've never been able to get this argument. It's a version management system! It's supposed to maintain the history of what's been done, both good and bad. In fact, that's the whole point of a VCS, isn't it?
IMHO, if we want to show a different path than what's been actually taken for the codebase to reach where it is now, we might as well use a network drive to store the different versions. Why bother with a VCS then?
Maybe it what an ironical question ^^
And I don't know why (forces you to review and cofirm?), but I had never commited unwanted stuff with fossil. But I had with git, probably by using the -am flag without realising a whole new dir is now in the scope.
There are cases where you really do want an append-only leger, where tampering with history is malicious. -- But, generally, it's preferable to be presented with something tidy.
From some other comment in this thread, I get the impression it's possible to re-present a set of changes in a clean/tidy way? That seems a better way of putting it. "You can still have a clean view into a set of changes while preserving an accurate history of what changed".
What's hard to understand is why you'd be against the idea of tidy communication/presentation of changes in the first place.
...which is a very big advantage, big enough that it outweighs the disadvantages in my opinion.
With git, this kind of experiment would be hidden with a "reset hard", and probably will happen again when people forgets, someone says "didn't we try that a year ago?" but we have no records.
This is very helpful in small private teams, not so much in biggest teams (kernel), pass-by PR environments (github), or public CV-oriented repos (no mistakes allowed there, only pretty linear timelines).
In teams, only the history of what is committed to shared repo is important.
We disagree here, thus we prefer different tools. Nothing elitist here.
I have seen git people throwing away repos and start again just to hide mistakes/pivoting and look "pro" and "right from the start". Or worse, I have seen people botching repos to others rewritting history just to make them look clean. I embrace mistakes, and sometimes they become useful later to replay train of thoughs.
In the most common git setups, you never force-push to master - so a coworker can't rewrite history of master branch. Forges have protection rules, but even if your hosting does not, then the "git pull" will throw a ton of errors after history rewrites. So both fossil and git are similar in that regards.
On the other hand, unpushed branches can be rewritten any time in git.. but this applies to fossil as well. If you have not pushed your fossil changes, it's just a file on disk - you can delete it without pushing and no one will ever know you had intermediate version. Or work in "git" and only export to fossil (or svn or cvs or whatever) once things work.
Obviously that's going to take some figuring out for queries and aliases. But it seems doable to me.
Awkward, yes, but doable. AFAICT, they've provided a way to do things that go against their philosophy should anyone be inclined.
I am not sure if you used CSV/SVN before - I did. It maintained the history of what was done in a very immutable way. The branches were heavy-weight and were only used for Serious Business, we generally had a person responsible for branching/merging. You only committed stuff which was in great shape and passed all the tests, just like Fossil wants you now.
And there were manual source code copying, so much copying.
- You are writing a feature and got interrupted mid-work to work on something else - copy/tar those files and restore from svn (you could also do a second checkout, but that destroys your cache).
- Want to send incomplete changes to friend? run "diff" and send them the patch by email, or place that patch file on shared disk.
- Your check-in failed, you need to merge in in latest changes from master? better tar up your work in case you break stuff.
- Are you doing new feature and want to see if refactor will improve it? don't forget to make a copy of changed files in case it does not.
None of this is worth committing on master. Who would want to share an incomplete feature which does not build / does not pass unit tests? Or an pre-refactor version of code which does not work?
Turns out using "git" covers all those usecases, and that's why it's the greatest thing. Fun fact: we've started using git in our team using git-svn, without central git server - we had mutable and shareable commits until the last moment, when we pushed it to central svn server.
IMHO, if you only want to record the final path code takes, and you plan to use "cp", "tar" and "patch" for throw-away work, then you might as well use a "releases" directory on FTP with timestamped archives. Why bother with VCS then?
Ideally a repo needs to reflect the state of every event that happened. Practically there are edge cases when it's just best to rewrite history.
Since the whole tracker is just a thin front on sqlite with the above features there's many options. Use it per-project persistently so as to include co-workers, or only locally for your own agents to "think" inside of so they are less likely to dump CoT all over the code-comments. Use it even at a per task granularity, and throw it away afterwards. Do all three, fossil doesn't care! And the agents will love it.
Funnily enough, that's collectively fossil's developers' least-favorite part. We make no secret about not liking the ticket system, and we only use it when we need to record a certain ticket for posterity's sake. Aside from that, we use the forum for all ticket-like traffic.
> Since the whole tracker is just a thin front on sqlite ...
Except that it's not: <https://fossil-scm.org/home/doc/trunk/www/fossil-is-not-rela...>
Fossil has no way to fix it, by design, and I find it an absolute showstopper. I do stupid mistakes all the time, and I am so glad that gits lets me fix those.
Those operations are explicitly declared special, not something you do many times per day because you had a typo in your print statement. I guess technically you can do it often, but the tooling does not make it easy at all, and you are going against program's recommended best practices.
Then you have proven that you are human.
> Fossil has no way to fix it, by design,
As an 18-year-long contributor to fossil i can assure you that this is absolutely not true. Fossil can amend any checkin and it can move checkins to other branches. Go to sqlite.org/src/timeline?r=mistake to see many examples of where human failing has been both demonstrated and accounted for without breaking anything.
The first line of the article says:
"People at Git has started to work on a proposal to make the Rust programming language mandatory."
This sounded to me like all future code would need to be Rust.
But the Git mailing list email says:
"Announce that Git 3.0 will make Rust a mandatory part of our build infrastructure."
Also, the original Git mailing list email says:
"[author is porting to Rust the...] "varint.c" subsystem, mostly because it is trivial and does not have any dependencies."
So, the email on the Git list says they are testing changing a small piece of C code to Rust, and Rust build tools will be mandatory [to build] (which is not surprising if a non-optional part of the code base is Rust).
oh great, another weirdo
This is by far the most perplexing part of this article for me:
> People at Git has started to work on a proposal to make the Rust programming language mandatory. I don't like Rust and, above all, I don't like its community of little extremist characters who are trying to make everyone swallow their crap by rewriting projects that have been working for decades, doing social media brigading, and other nice little gems worthy of any tiny group with totalitarian delusions. That's why when I see that a project aims to "force" the use of or the switch from C to Rust, to the extent of my possibilities, I flee from it as if I were pursued by the Balrog of the Lord of the Rings with his whip.
I've been programming for a longish time, and I've acquired my own set of opinions about programming languages, but I can't think of any that I dislike so strongly that I would need to boycott projects that use them under the hood. Moreover, even if we accept the "community of little extremist characters" claim for the sake of argument, is that at all relevant to the Git situation? I haven't seen any evidence that introducing Rust into the code base is the result of extremism, rather than just a mundane technology choice. Finally, when Rust is made "mandatory," it does not mean you must use Rust now, it just means that Rust is required to build the source code. The vast majority of people wouldn't even know that Rust was used. Even most Git developers wouldn't need to use Rust, since after more than a year from the original proposal, the Git source tree is still almost entirely written in C and shell scripts, and the amount of Rust code is basically a rounding error.
The whole Rust issue seems like a big nothingburger, and this reaction seems completely irrational to me.
rust solves a real problem. It makes it much harder to create a large class of bugs, bugs that are in most C and C++ projects (and many other languages). Sure, maybe rusteans have bad attitudes. Not sure that's true but I do get the annoyance of "I re-wrote cat in rust!".
We see these C/C++ bugs all over. Mozilla just fixed a ton of them, most of which would not have existed if Firefox was written in rust (see servo). That doesn't mean there would be zero bugs. It means there would be less. But by some accounts, a ton less, especially of the security issue kind.
And it's not just about the op, the op being a perfect expert programmer who never writes bugs. It's about someone quits, someone who doesn't know the code as well and takes over, they quit, someone who knows the code even less takes over, and in that world, the person adding a new feature to the app/tool/library is far less likely to add a security bug to a rust repo than an C/C++ repo.
> rewriting projects that have been working for decades
They have been working for decades AND are full of security bugs!
Switching them to rust generally means (1) the existing security bugs are gone (2) most future updates are far less likely to add new ones.
Note: I'm not a rust programmer. I'm a C++ programmer dealing with the fact that there are so many UaF bugs in our code with > 1000 programmers. We know more will be added because C++ does not prevent them and we're not perfect. Rust does, or at least it prevents enough of them to be worth it.
The friction is not an issue of the language or of toxic communities but the culture of how software is crafted and passed on. I use rust for hobby projects and besides the savety and soundness decisions, i love the tooling. Having countless [0] very restrictive guard rails like deny(clippy::float_arithmetic) for your usecases codifies intent about project structure in a way i have seen nowhere else. Not engaging with the benefits of rust but instead blanket-dismiss projects based on unrelated issues is irrational and i suspect its a phenomenon of older generations that grew up with C and never inherited eg. cobol on mainframes.
But Rust is actually a better language than C, in multiple ways; and it is in fact bad that so much software in common use is still written in C. C is extremely hard to write correctly and hard to maintain; this fact explains a huge amount of security vulnerabilities in the widely-used software written in C. Rust mitigates this to a large extent, and is also just more pleasant to write because it has better syntactic and semantic affordances than C does - also better developer tooling.
I think that people who are not Anglophone left-progressives should use Rust, in part because I think it is bad that a highly useful programming language is associated with Anglophone left-progressives. Certainly, regardless of one's non-programming-related political beliefs, you should not ground your identity in making a virtue out of sticking to C.
Off-topic, but I kinda like the style sheet of this article.