A Desktop That Will End The Desktop Wars
Posted 19 Jan 2004 at 06:03 UTC by nymia
The problem why there are so many battles and wars on the desktop is primarily due to lack of standards. Most of the desktop models rolled-out nowadays contain vendor specific implementation that is usable within the vendor definition. As a result, no interconnection between dissimilar environments (brandwise) exists. One can see some interfaces that work while others are only available on one, missing on another.
To address this issue, a standard desktop interface definition is required. The W3C.org has a set of DOM interfacces [1] that can used to build the Desktop Interface (DI). New desktop related interfaces can be added on top.
In effect, vendors will have a guide on what the standard interfaces are and from thereon add their own specific features called 'value adding.'
Below is a sample interface definition.
interface HTMLDesktop : Desktop {
attribute DOMString title;
readonly attribute DOMString referrer;
readonly attribute DOMString domain;
readonly attribute DOMString URL;
attribute DesktopElement body;
attribute DesktopElement desktopBar;
readonly attribute DesktopCollection images;
readonly attribute DesktopCollection applets;
readonly attribute DesktopCollection links;
readonly attribute DesktopCollection forms;
readonly attribute DesktopCollection anchors;
readonly attribute DesktopCollection applicationIcons;
readonly attribute DesktopCollection menus;
attribute DOMString cookie;
void open();
void close();
void write(in DOMString text);
void writeln(in DOMString text);
Element getElementById(in DOMString elementId);
NodeList getElementsByName(in DOMString elementName);
};
Once a set of desktop interface is ratified, these so-called wars on the desktop will subside, even disappear entirely.
That last sentence is where it completely breaks down.
But I wish it was true too. Heck, they could use XPLC to implement this, so that you'd have interface discovery (for finding the "value adding").
Hmmm, posted 20 Jan 2004 at 10:30 UTC by Malx »
(Journeyer)
Until "add their own specific features" is possible there whould not be any good of such standart :)
You could add only one feature or 300% of new features and it will break all.
And the meaning of "The Desktop Wars" are not about standart. They are about sale and development.
Eh?, posted 20 Jan 2004 at 14:48 UTC by elanthis »
(Journeyer)
What exactly are you trying to solve again? The Desktop these days has more standards than you can shake a stick at, thanks to FreeDesktop.org.
The Desktop Wars, as they're called, are almost entirely a thing of *design*. I.e., do you prefer the bloated and ad-hoc KDE design, or the clean and elegant GNOME design? (Ya, you can tell which camp I'm with, yes? ~,^ )
The interoperability issues between KDE, GNOME, Rox, XFCE, GNUStep, etc. are all being solved. The design issue is much more important, however - I'd rather not have "Random Applet" at all than have one which has the KDE look and feel to it on my GNOME desktop, as that design feels so alien on my system.
A standardized HIG would do a lot more for users than any kind of DOM-ish API ever would. Again, however, seeing as KDE and GNOME have some very different philosophies, I doubt any such HIG would ever exist, as it would mean changing not only opinions but also taste in various ways for both parties. (Not to mention the various design choices from the other Free desktops out there.)
Drum Beating Time, posted 21 Jan 2004 at 04:03 UTC by nymia »
(Master)
The Desktop Interface is simply a specification. Implementation is left entirely on the vendor or project. It can be implemented in any language: C, C++, Java, C#, etc.
There are numerous benefits of having a Standard Desktop Interface (SDI), one is having the ability to reference them as objects inside an interpreted language. A sample code shown below demonstrate the potential.
var MyTaskBar = New MyDesktopBar();
desktop.document.taskBar = MyTaskBar;
MyTaskBar.show;
The illustrious pphaneuf raised a good point and I agree to certain extent right before the wishful thinking part. Although there is strong possibility a well-respected org will bring it to fruition.
Also, my comrade Malx, adding features are allowed and are strongly encouraged, provided the implementation follows the interface. You are correct to say the possibility of having a broken implementation, vendors have the tendency of breaking interfaces and I won't name them here. Desktop Wars exist because incompatible implementations fight in one environment. The result: a cornucopia of apps with varying degrees of vendor specific API extensions.
Honorable elanthis, the goal is to minimize maverics who enter and break rolled-out APIs, which is so rampant. Both Gnome(G) and KDE(K) have demonstrated the possibility of creating a standard interface and are working towards a unification--in the interface layer--which will (I hope) be much better than what we have at the moment. Not to steal your words, but I think you have point too.
interfaces are good. i love interfaces: especially open ones.
issue: your definition of an interface doesn't include a communications mechanism.
e.g. COM, DCE/RPC, DCOM, Corba, SOAP (yuk) notDET, other.
if the interface is unspecified, it is necessary to define intermediary communications / translation mechanisms between the people who begin to implement the interface.
e.g. if someone implements a python interface and it's in, horror of horrors, XMLRPC (which was the XMLRPC author's way of "stepping up" a learning curve towards SOAP, and XMLRPC should never have seen the light of day. *sigh*) and some other person implements a perl interface and it's in.. mmm... SOAP, and the desktop actually runs as a DCE/RPC application, then it is necessary to have a communications shim service that fronts both XMLRPC and SOAP and makes calls via DCE/RPC to the actual desktop.
it's actually quite straightforward.
[btw for those people who may not be aware of it, COM plus DCE/RPC equals DCOM. or, more specifically, DCOM minus the remote bit of DCE/RPC equals COM, where COM was done solely for windows 95 because there was no way that the NT team could let the windows 95 team anywhere near the export-restricted security/authentication code in the NT implementation of DCE/RPC.]
XPLC is a bit like COM, save for the communication part, so you need that even more, as
lkcl said.
But I'd point out that almost all the mechanisms he mentioned are RPC-oriented, and the general feeling (including from Microsoft, who used to push about half of those he mentions) is that RPC-oriented (sometimes called "remoting") is "out" and message-oriented (sometimes called "messaging") in "in". For example, Microsoft now pushes Indigo instead, which is mostly based on messaging.
I'm not too up to speed on what's the message-oriented communication situation in open source, but I hear D-Bus is good.
Having a common level of understanding is probably the best step to take, simply because it places the focus in one place. Projects or groups involved in any desktop related work could in theory talk in a language void of implementation. A language good enough to store such abstract items can easily be described and communicated to others who are only interested not in how these abstract items will take shape, engaging in discussions as to how said abstract items can be modified and extended.
Take for example, communicating abstract desktop items in the forums of fd.o will improve considerably if a set of common abstract items are defined initially. A knowledge base may be created for record keeping, tracking the progress.
The main thing to remember is to not mention any specific implementation because implementations should only be covered only after a common set of abstract items are defined and ratified.