Very true, but just because missiles weren't ready to take over in Vietnam doesn't mean that they aren't ready today.

Vietnam also suffered from a lot of other problems. For one ROE - aircraft had to make visual identification before engaging, which basically negated any advantage the US aircraft even had. That and the general limited warfare thing which turned the whole theater into a meat grinder. Nobody was seriously bombing the bases the enemy aircraft were based at.

Vietnam was a LONG time ago now, much longer ago today than WW2 was back during Vietnam. People were quoting Vietnam this and that in the first Gulf War, and it wasn't remotely like Vietnam.

That said, unless the air force has some tricks up its sleeves that nobody knows about, the long-range missile capabilities of the US aren't really all that much better than anybody else's, which seems a bit crazy when they are relying on blowing up the bad buys before it comes down to a dogfight.

Well, the whole idea of the F-35 was that it was supposed to be the cheap replacement for the F-16, and hence the single engine. The problem was that they just tried to do too much with it, because heaven forbid that it isn't the absolute best in every category. By the time they really get it operational everybody will be using drones for this sort of thing anyway. Think about it - the mission of the F-35 is to be the bulk of the force, but not the aircraft you send in on the most critical air superiority missions (that is the role of the F-22). I'd think that would be the sort of thing you could easily use a drone for - take off, drop bombs, come back, and if AWACS spots enemy fighters either engage if you greatly overpower them, or just run and let the F-22s deal with them. Just have lots of ground crew taking care of the drones and you could basically have those things up in the air most of the time.

I also don't think that dogfighting is the real threat here. I already mentioned long-range AA missiles, but SAMs are a big threat too. Russia has those SA-10s which as far as I understand are VERY capable. I have no idea how well stealth defeats them, but they're really bad news for aircraft in general. Maybe they're counting on cruise missiles taking them out.

I stand corrected.

However, if you do want file versioning on every save, I'm not convinced that zfs/btrfs are great solutions.

If you do the leading edges and windscreen with furniture polish (people swear by Lemon Pledge, I use Mr Sheen because Pledge doesn't seem to be sold locally) the bug guts wipe off very easily (and I suspect many just don't stick but I've not done a scientific test of this).

Take an awful lot of Pledge to do an airliner leading edge, though.

I use Mr. Sheen on our aircraft. Lemon Pledge isn't available here. Mr. Sheen seems to do the job just fine.

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?