To clarify the comment re: Bill Gates biggest regret, his biggest regret according to the referenced article was that Microsoft never shipped WinFS. He did not regret the product itself. It was unclear to me what the parent meant, as my first question was, "If he regretted it, did he allude to reasons why it's a bad idea?" But that question no longer makes sense when you realize that the Mr Gates ostensibly still believes in the idea.

I remember reading this from Bill Gates on his reddit AMA:

> We had a rich database as the client/cloud store that was part of a Windows release that was before its time. This is an idea that will remerge since your cloud store will be rich with schema rather than just a bunch of files and the client will be a partial replica of it with rich schema understanding.

Then he confirms few comment later that he was talking about WinFS.

https://www.reddit.com/r/IAmA/comments/18bhme/im_bill_gates_...

I was researching WinFS recently and came across this series of posts explaining its vision:

* https://hal2020.com/2013/02/14/winfs-integratedunified-stora...

* https://hal2020.com/2013/02/14/winfs-integratedunified-stora...

* https://hal2020.com/2013/02/25/winfs-integratedunified-stora...

* https://hal2020.com/2013/03/10/winfs-integratedunified-stora...

While WinFS was a good start, I think the idea of a semantic file system could be extended much further to the whole system (if it weren't for pesky POSIX)

I think most people would expect

/home/geokon/program1/src/

and

/src/program1/home/geokon

to have pretty much the same content

A tag based file system that makes the two equivalent would eliminate all sorta of annoyances where you can't decide how to structure your file hierarchy (should you have bin/program1 bin/program2 sr/program1 src/program2 or program1/src program1/bin program2/src program2/bin? both layouts have their advantages).

Something like a "path/path/bin/path/path/bin" wouldn't work.. but it's hard to find a case where you really need it. And the vast majority of time the subfolders aren't strict subsets of the parent (like mammals/dogs mammals/cats mammals/whales - where dogs/mammals would be a little weird)

Years ago, I had a similar idea, but never did anything with it. Look at DNs in LDAP (and X.400/X.500), they are based on attribute=value pairs. What about a filesystem in which filenames were collections of attribute=value pairs?

e.g. /home/geokon/program1/src/foo.c

could become: user=geokon/program=program1/category=src/lang=c/name=foo

You could potentially decide that the order of the attributes is not significant, only the set of attribute-value pairs.

Downside: Too much typing. Although, maybe you could allow standard aliases for attribute names, so that:

user=geokon/program=program1/category=src/lang=c/name=foo

could also be written as:

u=geokon/p=program1/c=src/l=c/n=foo

(I think the attributes should be first-class filesystem objects, just like files are, as opposed to just text strings. Some of the values, e.g. an enumerated value like lang=c, should be first-class objects as well.)

I also took some inspiration (in concept not syntax) from https://en.wikipedia.org/wiki/Faceted_classification such as https://en.wikipedia.org/wiki/Colon_classification

Being too different from what everyone else is doing would be the real killer, however.

Just write geokon program1 src c foo, and then just display a list of files that match. You could for example also make fake folder/menus to navigate tags. (Which would just be appending filters.)

There's a project that kinda wants to do that, ie provide a virtual interface on top of the existing filesystem based on tags you give each file: https://tmsu.org/

That was my first thought, too. I'd love a file system that was more like a relational database.

Also see the Pick operating system.

Transactional ACID updates to file systems would be pretty fantastic.

yes. thinking about this for a long time already

BTRFS has had a bunch of problems trying to actually compete with traditional filesystems, though. In the distributed world, CalvinFS seems pretty promising to me.

I always wanted the file system to be built on a version control.

Also MUMPS. See https://en.wikipedia.org/wiki/Pick_operating_system for info.

In some ways, Microsoft is on the way there with the way PowerShell works, and the ability to script things through OS functions that return objects which can be queried. If we ever see a WinFS, it would be very powerful combined with PowerShell