Re: Seeking for papers about tagged types vs access to subprograms

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Wed, 15 May 2013 13:31:36 +0200, Peter C. Chapin <PChapin@vtc.vsc.edu>  
a écrit:
> The genius of the Linux (and Windows) way of representing files is that  
> the operating system does not need to know anything about the nature of  
> the data being stored in the files. Thus new file types can be defined  
> by applications without any OS changes. This does push the burden of  
> interpreting the file's format into the application but the benefit is a  
> more generic operating system. When one considers all the different  
> kinds of files created by applications today, I can't imagine any other  
> way working well.

I may see a better options: what about multiple views for a file? File  
view drivers? Query interface to query what interface(s)/view(s) a file  
provides? A standard format to describe interfaces? Standardisation of a  
basic set of very common interface (which may be completed as the  
technologies evolves)?

Pushing this kind of responsibility to the applications, is the surest way  
to have a mess of non‑interoperable things, wasting duplicates,  
inconsistencies, data corruption, applications guessing all the time, etc  
(and that's indeed how it goes so far). Just imagine what if each  
applications was responsible of accessing devices or managing memory  
pages. The comparison is not that much excessive: nor POSIX nor Linux  
provides anything for mandatory locks on files (at least, Windows is  
cleaner on that aspect), and it only works between cooperative  
applications (modulo their bugs) and can be fully ignored accidentally or  
worst, on purpose, by any other application.

There is too much responsibilities left to applications in this area. The  
OS discharges itself from near to everything but storage devices access  
(or may be an OS is just a big device driver), which is just a way to say  
it provides near to no service at all here (except a stream of raw bytes),  
and each possible view must be a duplicated feature in each application  
(or multiple shared and overlapping non‑standardized libraries, which ends  
into others and similar issues).

Even determination of the MIME type of a file does not work well, and may  
have to be fixed by some application (just think of `file` and `xdg-mime`  
on Ubuntu, not always returning the same answer for a query). What the OS  
or environment does not provides, each application has to duplicate it,  
and may be wrong with or may miss some point.

That's one of my biggest (*) grief with OS (at least widespread OS, as I  
don't known others nor old ones).

(*) Another big one is about applications each believing it's the centre  
of the world, which comes with similar consequences: wasting with  
duplications, inconsistencies, poor UI behaviour standardisation,  
encumbered workspace, and so on.

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University