Only if it is implemented as such. It probably isn't.

Suppose you have a file which was modified once (ie there are two versions). The overall filesystem has files which have had 3 billion modifications. You have 3 billion trees and the leaf node for that file in each tree points to one of two versions.

The smart way to search the tree is to compare all the roots and eliminate any which aren't different versions (there won't be any at this level, since new roots are only created for new snapshots). Then you descend one level in each and eliminate all which aren't different versions (which will eliminate 99% of the records at this level, since if you snapshot on a single file change most nodes will be shared across two trees except the one containing the one file that changed). Then you keep going down eliminating duplicates in this way. In the end you'll have a bunch of linked lists from root to leaf showing the one file that changed in each new root (a tree with only one node per level is a linked list). Then you search the leaf nodes for the file of interest and generate a linear history for that one file. If you are targetting a particular file then you can stop your search early on most of those trees anytime you discard the parent of the desired leaf (if you're looking for changes in /etc/passwd and in this tree only an unknown file in /usr changed you can stop searching).

That is still a lot of work, because there was no linkage between file versions in the data structures. A filesystem optimized for file versioning would store a link from each file to the previous version so that the history for a single file could be traversed with only one seek per version.

However, doing this from userspace is going to be even less efficient if the filesystem doesn't expose its internals. In userspace you have no visibility into which directories under a snapshot are a shared record in the filesystem. To trace the history of a single file requires descending to that file in every single tree, and doing a full comparison, which is far more operations than in the optimal algorithm. To trace the history of the entire tree requires comparing every file in every snapshot, which is an enormous number of operations even in RAM, let alone on disk.

If you've ever tried to do a git log on an individual file in a very large git repository you might have noticed this problem, and I believe git does things in the optimal way. (Git repositories are very similar to COW filesystems.) If you stuck your entire hard drive into a git repository and did a commit on every change, you'd quickly run into this problem.

To do this well really requires designing the feature into the filesystem. Doing it in a COW filesystem is especially challenging since if you want to remove a snapshot you need to potentially clean up broken links at the leaf level if you're actually linking across snapshots so that you can easily traverse file histories.

Sure. Perhaps you've heard of bigamy? Alice can't marry Carol because Bob already has a vested marital interest with Alice. For example, if Alice marries Carol and dies, Carol is entitled to 100% of her assets as spouse. But so is Bob.

That's not the policy rationale for the prohibition on bigamy, and while it is perhaps a little better of a reason than administrative convenience, it boils down to the same thing, since the question of marital property is one of the issues that legislatures will have to address when the ban is overturned as it inevitably will be.

On the contrary, tradition is absolutely relevant as to whether something is a fundamental right. Marriage is a fundamental right because it's enshrined in our traditions and collective conscience. ...
Polygamy does not have such a place in our traditions or collective conscience, and therefore is not a fundamental right.

Yep, that's the bullshit argument that people were rolling out against same sex marriage all right. That because it wasn't traditional, it wasn't fundamental.

The core mistake with that argument, whether in the context of same sex marriage or marriage among persons already married, or in larger numbers than two, is that what's fundamental is not opposite sex marriage, or same sex marriage, or polygamous marriage, but simply marriage, without qualification of any kind.

Issues like gender, race, consanguinity, marital status, and number of spouses are all restrictions on that singular fundamental right. Whether they stand hinges on whether they can be justified. Two of them, it transpires, cannot be. Ultimately I think the only restriction that will hold up will be consent, and perhaps consanguinity will have to be reframed in terms of consent if it's to be salvaged.

Agree that this is a challenge. It would seem to me that the simplest solution would be to create a version anytime you close the descriptor. I realize that some activities that keep files open for long times would not create versions, but for most mainstream cases it would probably work. It would certainly work better than just taking random snapshots at random times when a file might be half-modified.

A solution does not need to be perfect to be useful.

I suppose, though that still leaves you with the challenge of finding all the versions of a single file. I'm not as familiar with the zfs internals, but I don't believe there are any data structures in btrfs that make it easy to traverse all the versions of a single file.

Well, the whole idea would be to have simple snapshots of every file version without having to re-implement every application I use.

And it sounds like the answer to my second question is no. btrfs works in the same way. The snapshot is at the filesystem/subvolume level, and if you want to find all the versions of a particular file you basically have to find the file in every snapshot that exists and diff them all.

I love btrfs. I just don't think that it solves this particular problem, and neither does any other linux filesystem. The fact that nobody has implemented this on linux doesn't make it any less useful.

He never said he was happy with Windows Server's versioning.

He did mention sharepoint, which does retain a version on every file save.

I'm well aware that zfs and btrfs can be told to snapshot the entire filesystem as often as you want to fire off a cron job.

While I agree in principle and I'd love to see states get rid of marriage legally, I do think that it will take a lot more reworking of laws to make it happen.

For example, in Pennsylvania any number of random people can buy a house together and each own a portion of the property. However, only a married couple can buy it such that they each own 100% of it. The practical difference is that if one property-owner has a lein in the first case, then the lein remains against their share of the property up to the value of that share even if that owner dies. However, in the case of a married couple if one member of the couple has a lein against the house and the other does not, then upon their death the lein does not remain against the house because the other owner already owned 100% of it and the dead owner is simply struck from the deed.

So, there are likely situations where marriage does get special treatment that need to be resolved.

However, I do agree that there isn't any situation handled by marriage that could be legally handled in some other way, and I'd love to see marriage become purely a cultural/religious/etc arrangement with no legal basis at all. You could still have standard contracts for property ownership among couples just as there are standards for contracts for buying/selling houses, and individuals could enter into these or modify them as they see fit.

Can you make it snapshot anytime a file is modified? Also, can you easily find all the snapshots for a single file? Or do you just have 3 million subdirectories where a given file might or might not change between any random pair of them?

Can ZFS actually do versioning on every file close? I know it can do snapshots, but of course btrfs can do that as well. I'd think that the goal of a versioning filesystem would be that versions are captured anytime a file is written, not just when the admin hits the snapshot button, or once an hour, or whatever.

As far as I've seen the COW filesystems only do snapshots when they're asked to, and I'm not sure they're designed to scale to the point where you have billions of snapshots for millions of files.

Isn't that a bit like saying that there were HUNDREDS of programmers involved in combing over every line of that software. Do you really think that it could contain a bug?

You're suggesting that the principle that is the reason that all software contains bugs be the bedrock of jurisprudence?

Perhaps, but the intent of the writer isn't nearly as important as the intent of the congressmen who voted for it, likely not having even read the entire thing.

When you write laws that are hundreds of pages long, it will be like writing software hundreds of pages long, and there will be bugs. The solution to legal "bugs" is to fix them, not pretend we're computers. That is what the court did.

If Congress really intends for Obamacare to go into a death spiral, they can always pass a law to make that happen.

because, as noted earlier, 3>2. Equal protection is an issue where two groups that are equally situated are treated differently. For marriage, there is no difference between a gay couple and a heterosexual couple. There is a difference between a couple and a larger group, however.

The litigant needn't be the entire group. Marriage is a fundamental right, subject to various restrictions, such as consent and consanguinity. Yesterday, one of the restrictions, at least in some places, was that the genders of two of the spouses couldn't be the same. Today, it's fine nationwide if they're the same.

The restriction to look at now is whether the marital status of each spouse in the marriage at hand is single. Today it has to be. But there's not a good reason for it. (As already mentioned, administrative convenience is not a good reason). So why can't Alice, who is married to Bob, now also marry Carol? Bob isn't marrying Carol; the A-C marriage would be between two people only. You're treating Alice differently merely because she is already married.

It's also not a fundamental right, as polygamy is not part of the traditions and collective conscience of society, except for Mormons.

Marriage is a fundamental right and is extremely broad. Restrictions on marriage, such as requiring the spouses to be of opposite genders, or of the same race, or of the same religion, or of compatible castes, etc. are not inherently part of marriage and are certainly not part of the fundamental right of marriage.

Also, today's events make it clear that tradition is irrelevant; polygamy is practiced today among many groups, and has a long history back into antiquity. Same sex marriage was known in the past but was far more rare.

No, we're Americans, but that fact was established by the Treaty of Paris instead.

It will certainly be a massive pain in the ass. But administrative inconvenience is not an adequate justification for denying people their fundamental rights or equal protection of the law. It'll take a while, but just as this took a while, but in time polyamororous marriages will be legally recognized.