|
I do think that they are right about many things, although I have my own ideas about how to improve them (and I do not agree with all of the ways they (Ink & Switch) are doing with it). In UNIX systems you can use pipes between programs (if the programs support that; many modern programs don't support it very well), although there are still problems with that too. (I also disagree with the idea that text (especially Unicode text, although the objections apply even without a specific character set) would be the universal format.) My idea of a computer design and operating system design is intended to do things which will avoid the problems mentioned there (although this does not avoid needing actually good programming, and such things as FOSS etc still have benefits), as well as having other benefits. Some of the features of my design are: CAQL (Command, Automation, and Query Language), UTLV (Universal Type/Length/Value), and proxy capabilities. (There are more (e.g. multiple locking and transactions), but these will be relevant for this discussion.) Like OpenDoc and OLE, you can include other kind of things inside of any UTLV file, by the use of the UTLV "Extension" type. The contents of the extension would usually itself be UTLV as well, allowing the parts to be manipulated like others are, although even if the contents isn't UTLV (e.g. for raster images), you would have functions to convert them and to deal with them anyways, so it will still work anyways. With those things in combination with the accessibility (one of the principles is that accessibility features are for everyone, not only for the people with disabilities; among other things this means that it does not use a separate "accessibility" menu) and m17n and other features, you can also do such things as affect colours, fonts, etc, without much difficulty. (They might not seem related at first, but they are related.) I had also recently seen https://malleable.systems/mission/ which seems to be related (you might want to read this document even if you are not interested in my own comments). One part says, "If I want to grab a UI control from one application, some processing logic from another, and run it all against a data source from somewhere else again, it should be possible to do so.", and with CAQL and UTLV and proxy capabilities, this can be done easily, because the UI controls are callable objects (which can be used with CAQL) like any other one, the data source can use UTLV (which can be queried and altered by CAQL), and the interaction between them can use proxy capabilities. |