Which are good modern version control systems (VCS)?

As I said, that isn't more or less likely than on independently published source code.

You generally can't block scrapers from accessing source because you need things like ports to be able to download it outside a web browser.
Surprise, surprise, HTTP uses port 80, HTTPS uses port 443, all possible using browsers.
 
I mean, even good-old-CVS is sufficient for NetBSD and OpenBSD. In fact, even an OpenBSD developer stated that CVS is good enough for them and there is no reason to switch: https://cvs.afresh1.com/~andrew/o/why-cvs.html

I think that FreeBSD's switch to git was rather pointless. What problem did it solve? No-one seems to be able to give an answer. Also, it was basically an encouragement of GPLed code. SVN was under the ALv2. Git is under 'GPLv2

My understanding is that OpenBSD hacked up CVS to do a few more tricks, such as atomic multi-file commits.

The FreeBSD move to git was unavoidable because svn sucks.
 
On systems without ZFS I tend to track /etc with git: `cd /etc ; sudo git init . ; sudo chmod 700 .git ; sudo git add . ; sudo git commit -m init`

And then you can track any changes with `git diff` & `git status`.

I love this. I typically use RCS though so I only track the files I edit. It's a great idea.
 
These days, I run mercurial for all my hobby projects. I used to like Perforce a lot, but that was 20 and 15 years ago. I strongly dislike git. The worst one I ever had to use was Rational's ClearCase.
Yeah, that was bad, though it introduced me to three-way diff and I never looked back. Did you ever have the misfortune of having to use Microsoft Sourcesafe?

I guess I'm the lone Git fanboi here. I'll do my duty and represent. I led the migration away from SVN and to Git at the startup I was at in the Aughts. SVN was absolutely killing us. Our development model was one of long-lived development branches that were merged back to trunk shortly before they were deployed. This meant that the development branches had trunk merged to them several times during their lifetimes. This was fine until you tried to merge a branch with that history back to trunk. SVN would stupidly find a conflict for every single commit that had been previously merged into the development branch.

What this meant is that we had a rotating merge monkey who got to spend up to three days figuring out which conflicts were noise and which were real. It was boring, thankless work that demanded extreme focus and attention. I and others missed a merge more than once and had a prod deployment go sideways cause we'd removed a previous fix. We moved to Git and all those problems went away. It was almost magical. I was highly skeptical of re-writing history back then, but have since embraced it with enthusiasm. I now carefully curate my commit history by rebasing, squashing, and splitting commits aggressively. A clean, logical commit history makes it so much easier for others to review your code, and to figure out why changes were made even in the distant past.

I had struggled with CVS at a previous job where we also had a designated merge monkey. That duty usually took a week there because it was a much larger project and much larger engineering org.
 
Yeah, that was bad, though it introduced me to three-way diff and I never looked back. Did you ever have the misfortune of having to use Microsoft Sourcesafe?

I guess I'm the lone Git fanboi here. I'll do my duty and represent. I led the migration away from SVN and to Git at the startup I was at in the Aughts. SVN was absolutely killing us. Our development model was one of long-lived development branches that were merged back to trunk shortly before they were deployed. This meant that the development branches had trunk merged to them several times during their lifetimes. This was fine until you tried to merge a branch with that history back to trunk. SVN would stupidly find a conflict for every single commit that had been previously merged into the development branch.

What this meant is that we had a rotating merge monkey who got to spend up to three days figuring out which conflicts were noise and which were real. It was boring, thankless work that demanded extreme focus and attention. I and others missed a merge more than once and had a prod deployment go sideways cause we'd removed a previous fix. We moved to Git and all those problems went away. It was almost magical. I was highly skeptical of re-writing history back then, but have since embraced it with enthusiasm. I now carefully curate my commit history by rebasing, squashing, and splitting commits aggressively. A clean, logical commit history makes it so much easier for others to review your code, and to figure out why changes were made even in the distant past.

I had struggled with CVS at a previous job where we also had a designated merge monkey. That duty usually took a week there because it was a much larger project and much larger engineering org.
Git is great. The UI is a bit weird and the default hash (SHA-1) could have been parameterized to avoid the whole mess of migrating to SHA256, but nothing is perfect.
 
fossil was over plain text, which often doesn't matter for VCS, or it had to do with data integrity. I possibly misread it. Tried looking for it, but couldn't find it again. I'll cross it out. If information about it comes up, it can be re-discussed.

Fossil SCM is interesting that the same creator of it, D. Richard Hipp, also created Sqlite. It seemed that Fossil used Sqlite as a dependency, but I don't see this dependency chain on FreeBSD. Hipp used Fossil to aid in Sqlite development.
I use fossil. For files I would use RCS.

Fossil has sqlite3 as dependency: it is compiled with it. Fossil saves the commits as sqlite3 db.

It belongs in some way, as sqlite3, to the tcl/tk culture. Tcl/Tk uses it as repository.

It is in some sense not 100% unix, but a Swiss knife in one executable.

Workflow play a role in the selection of VCS. One could say, fossil is for cathedral, git for bazaar.

It is distributed like git, not central like CVS. Communication through https, generates a nice web page. Example is the very page of fossil:


You can see the similar one of tcl:

 
I recommend git.

Now, git is used for ports, while portsnap is still an option in ports. There's still net/gitup available. The full git takes a bit of learning. There may have been an opensource book on it. The full git takes a lot of learning to do simple commands, and to recover the files and condition to a previous state.

here is the book: https://git-scm.com/book/en/v2 ... with git, I am sure you will learn the few commands you need on a daily basis very fast.
 
Did you ever have the misfortune of having to use Microsoft Sourcesafe?
Yes. It was perfect. This was in the mid or late 90s. Our group was about 5 to 20 people. Sourcesafe ran on our manager's desktop machine. He left it on when he went home, so everyone in the group would be able to use the SCM. Our development process was completely linear (no branches, no tags, no merging), and files were committed one at a time. It was flawless, and super easy to use. But that was in a world where requirements were much simpler.

Our development model was one of long-lived development branches that were merged back to trunk shortly before they were deployed. This meant that the development branches had trunk merged to them several times during their lifetimes. ...
I was in a similar situation in the early 2000s. Our project was to integrate multiple components that came from different research / development groups: A cluster file system, an object store layer, a cluster management system (config, hardware control, scheduler), and the code for actual OSDs (yes, we had object disks, that was considered hip and cool at the time). That meant our "coding" work consisted mostly of merging separate streams of changes that came from different directions, and different SCMs of their own. After considerable research, we picked Perforce, since it had (a) the best merge support in the industry, and (b) a reputation for superb customer service and hand holding. This is in the spite of the fact that our company (IBM) had a half dozen SCMs they sold (including Rational ClearCase). Perforce worked beautifully, very little hassle, when things didn't work I just called their 800 number and got help. The cost of a few thousand $ per developer was a great investment.

We moved to Git and all those problems went away. It was almost magical.
I had the opposite experience with git, about 10 years late, in the mid 2010s. Here we had a large project (probably millions of lines of source), and one guy by himself working offline over two years to make a major modification to it. Because that modification was very risky, it could not be done on the main trunk, and had to remain on a branch. The problem was that at the same time as the one person working full-time on his branch, a group of a few dozen people were modifying the trunk continuously. For a while, the one branch developer was willing to do a weekly merge of trunk changes back into his branch. Git did horribly badly, and most merging had to be done by hand. After about 3 months, he gave up. Unfortunately, I was dumb enough to volunteer to help him, and manage just the weekly merging. The first week took me several days to catch up. After that, for a few months it was a few hours per week. Then it went to several days per week. For about one month, I worked full-time simply merging code all day long (to support one developer, but one super hard working one), fighting git every step of the way. To use your language: this task killed the merge monkey.

We decided to give up, and our colleague did all his development on an obsolete branch, knowing that the code would have to be thrown away. After about two years of working on the project, we literally threw all the code away, looked at the diffs, and in the span of a few weeks retyped it from scratch into a short-lived branch.

That horrible experience is why I hate git. And I have developed a strong allergy to branching. It can be made to work, if the semantic distance between trunk and branch stays reasonably small, and if you are using a REALLY good tool (the only one I know firsthand is Perforce).

If you look back at the best book about software engineering (The Mythical Man Month), it clearly explains that every software development group (of ~10 people) needs to include one librarian. In the 60s, when the book was written, the job of the librarian was filing new code (on punched cards) into the drawers of code (steep cabinets with lots of punched cards). Today the librarian is the person who operates the SCM for the developers, and becomes an expert on merging, branching, and cherry picking. Having that task distributed to all software engineers is insane, as it is a different skillset. A normal company wouldn't ask the software engineers to cook lunch in the kitchen either.
 
For the licensing purists, as pointed out above, there's got.
And antibloat purists. got has less dependencies.
For 'licensing purists' (developers), Fossil and got still needs git in some cases.
For 'antibloat purists' (developers), Fossil and got still have a dependency on git in some cases.

For 'licensing' & 'antibloat purists' (users) you don't need anything other than gitup.

If you don't want GPL: non developer: `gitup` developer: `got` or `fossil`.

Don't forget 'got' has code which you can use too.

My comment above was about how developers have "options" (e.g. code to make their own) and how developers can often times have a more relaxed stance on license (because many things are typically a mixed bag). -i.e. developers that do not want GPL will either have to roll their own or wait until Git network protocol v2 (for one example) is implemented in got. Chances are, that, currently, if a repository is in git, you will still probably need git for some task or another; fossil allows for a bidirectional thing, but you need the repo and `git --fast-export/import`.
 
Back
Top