3 ms·
>Cthulix is all about bilateral contracts, and hence discourages Files and multiparty filesystems. Sanity at last. Default access to a filesystem is the single
by mikewarot 5y ago
>Cthulix is all about bilateral contracts, and hence discourages Files and multiparty filesystems.
Sanity at last. Default access to a filesystem is the single biggest sin of Unix. It was a reasonable thing to do in the 1970s, but not since.
>Rather than having a filesystem, you would create an ETL that had multiple inputs (one from each producer) and multiple outputs (one to each consumer).
I strongly suggest a capability based approach to have read/writeable resources... but maybe that's not really the best way...
>Future work: build a gridapp that makes it easy to create bilateral File-like things.
Ok, I'm willing to ditch random access files because this is a multithreaded parallel world. A gridapp that allows for versioning of the state of a "file" and appending mutations that are enforced in a consistent manner, or are guaranteed to become consistent at some point, would be a very good thing. Think of the really old "Paradox" database that was internally append only and versioning, but appeared to be read/write when necessary.
---
I'd be happy to help write an implementation that spoke to Cthulix in Pascal on Windows/Linux/DOS/WebApp to have a second source in a completely different source tree.
Kah thu licks - right?
- beagle3 5y ago> Sanity at last. Default access to a filesystem is the single biggest sin of Unix. It was a reasonable thing to do in the 1970s, but not since. Novell Netware had what seemed to be a reasonable compromise some 30 years ago, called "Trustees" - it had a permission system (ACLs, if I remember correctly), but it was magical in the sense that you only needed to manage the ACLs of the leaf nodes; If you had access to a file in a path 7-directories deep, then you would automagically see the entire path (but only files you had access to in each directory); and if you didn't, neither the leaf not the 7 directories leading to it existed for you. A billion times easier to manage/reason about than the NT or Unix mess.
- baybal2 5y agoI see nothing sane in an OS without an FS.
- mikewarot 5y agoIt's an OS without a default permission to access a file system. Somewhere there must be a place where state is persisted. More than likely there will be a file system. You could certainly write a Unix/Linux/Windows program to run given a set of file handles instead of permission to the whole file system. Pipe based utilities don't really need a file system, just the pipes.
- skissane 5y ago> Default access to a filesystem is the single biggest sin of Unix Doesn't the widespread adoption of containers (Docker/OCI/K8s/etc) solve most of this 'sin'? You can make a container's root filesystem read-only (not always done, but recommended for maximum security), so its contents is always the immutable image from which the container was started. You can also provide the container with additional read-write volumes if it requires them (such as to persist state). In systems I've worked on, most of the containers are stateless, and they store their data in Cassandra/Postgres/S3/whatever, and it is only containers which host Cassandra/Postgres/etc themselves which have any persistent read-write volumes attached.
- southerntofu 5y agoEven without containers, managing permissions across some apps is not that complex for most workflows. Now try to introduce human users and all hell breaks loose unless you have actual ACLs. This part of a sibling comment deeply resonated with me: > If you had access to a file in a path 7-directories deep, then you would automagically see the entire path (but only files you had access to in each directory); and if you didn't, neither the leaf not the 7 directories leading to it existed for you.
- skissane 5y ago> Now try to introduce human users and all hell breaks loose unless you have actual ACLs. Most apps I've worked with don't use filesystem ACLs for user-facing security. Suppose you are building a document management system. You might store each document as a file on a filesystem–but you probably won't store "who can access what document" as filesystem ACLs. You'll probably just have a filesystem ACL giving the application access to all the documents, and then enforce user-level access in the application code, with the user-level permissions stored in the application's database. Human-managed permissions turn into a mess no matter what you do. But enforcing them at the application level, you can make the implementation actually understand some of the business rules which drive them. In a B2B setting, you might have a business rule that for each customer account there is a list of authorised employees allowed to work on that account, plus some workflow process to get approval to permanently or temporarily add an employee to that list. A lot less mess if you build a database and UI around that business rule, than if you just try to store that directly in filesystem ACLs. A document management system can even export the documents as a network filesystem (WebDav, CIFS/SMB, NFS, etc) – but it doesn't have to properly implement filesystem ACLs in doing so, if users want to manage permissions you force them to use the Web UI instead.