Slashdot Mirror
Hackers on Linux's Exciting Desktop Future
Gentu writes "OSNews features two interviews with prominent open source developers: Robert Love started working at Ximian this week and he will be leading the 'effort to improve the Linux desktop experience via kernel development'. In this Q&A, he explains what he will be working on hardware integration, freedesktop.org's D-BUS & HAL, low latency optimizations, power management, X & 3D and a 'Linux answer to WinFS'. The second interview is with Red Hat's Owen Taylor. Owen speaks of GTK+ development and where he sees the project going in the Gnome 3 timeframe: freedesktop.org's new X server, Cairo support, GTK#, OpenGL & other widgets and more."
Many people are probably going to say that GUIs are inherently object-oriented, as they attempt to reconcile programmatic constructs with tangible objects. But the fact that GTK+ isn't implemented in, say, C++ isn't necessarily as bad as it sounds -- I don't think extending classes is particularly useful for GUI programming -- by deriving, you're either essentially encapsulating the parent class's functionality along with other functionality, or doing weird stuff to the internals of the parent to extend it. What's really important is that GUIs are concurrent and event-based, and hence the primitives which are reused all over the place need to be as well. Contrast a push-button, which generates an event for the containing program to handle whenever the user decides to click on it, with a square-root function, which only when instructed by the containing program takes a value, performs a finite amount of computation, returns another value, and stops. This is why Qt has its signals and slots. This is why TCL/Tk has been used so much for GUI programming despite its terribly lacking language features. This is why Java uses threads in its GUI frameworks. This is why the failed BeOS focused on highly efficient multi-threading. Although I agree that object-oriented encapsulation is essential for organizing the code of widgets, asynchronous lightweight concurrency is at least as important to make GUIs work. Derived objects, on the other hand, don't seem too useful for GUIs so long as you have interfaces or a good implementation of generic functions and type inference. Unfortunately, popular object oriented languages like C++ and Java don't really add this over C -- C++ is still totally sequential at heart, and Java's threads aren't particularly lightweight, nor is its huge library.
These advances must have been stolen from SCO...there is no way a bunch of random hackers could have thought them up an implemented themselves.
"We need a simple, low overhead, fast communication channel from the kernel out to user-space, to communicate everything from device status ("your processor is overeating")..."
I finally know why I am never satisfied with the performance of any computer that I have ever used. I used to think that operating systems and applications grew increasingly bloated in order to encourage me to buy a new computer. Now I know that computers perform poorly because the process or is overeating!
When I first used Linux and I ran X, my thought was "damn, this is slow."
I thought the same thing. Then, I saved my pennies and got rid of my 486.
How can we continue to believe in a just universe and freedom to eat crackers if we have no ale?
It seems that there are many here who are flaming any topic that relates to mainstream desktop penetration of Linux.
I thought this was the point of the GNU system? Isn't any step forward (KDE, GNOME, etc.) towards some degree of appealing to users a win for the Freedom of GNU?
When someone announces they will be working on a project -- low latency optimization, for example -- you can pretty well tell that they are *actually* working on it because the code is released and you can look at it. It might have mistakes, crash a lot, or be missing features, but another developer can build on it if the original coder leaves the project because of other commitments or just out of boredom.
On the other hand, with proprietary code you are never quite sure where you stand. The company holding the source can claim they are spending the next month concentrating their resources on security issues, and if the program appears to be as insecure and bug-ridden as before you aren't sure if the developers took a month-long cruise to the Bahamas and blew it off or if they are actually inept at security. If you depend on that program for your own product, you can't even fix the problems you encounter if the developer decides to ignore or even kill the product because the source code is secret. And for those that have a paranoid bent, it's entirely possible for certain companies to sow FUD by claiming to be working on some incredibly desirable improvement they have no intention of delivering, or to leave hidden programming hooks which allow only certain products to use it.
Too bad our founding fathers could not have forseen the entire source code/copyright issue. I would like to think they would have required complete specificity with regards to programs -- if you wanted to copyright a program, you would have to show exactly how it was created using industry-standard tools. It would not only prevent monopolistic power in one programming area (*cough* operating systems *cough*) from extending to another, but it would be one heck of a lot easier to prove copyright *infringement* because the source code from various products could be compared.
Copy&paste is still inconsistent in X and just annoying.
Copy-and-paste is completely consistent in X. As is the selection mechanism. What is inconsistent is the support by toolkits and applications for them. Unfortunately, Gnome and KDE both are to blame here. Instead of supporting X11 conventions, Gnome and KDE are each doing their own thing, mostly like Windows but not quite, and definitely inconsistent with X11.
When I first used Linux and I ran X, my thought was "damn, this is slow." This feeling is echoed by a lot of other people. It's nice to see that a replacement is on the way.
X is not slow--it's as efficient or more efficient as Windows GDI, and it runs rings around Macintosh's Quartz. All of them are, of course, client-server system so there is no particular reason why X should be any slower than the other systems.
What makes X-based desktops slow is the desktop environments themselves. In part, that's because some desktop environments try to emulate graphics primitives in client code that X11 does not support (e.g., transparency, anti-aliasing), and in part it's because they don't take into account the client/server nature of X11. And in part, it's because they are just slow completely independent of any display-related functions (e.g., inter-application communication, huge memory footprints, etc.).
Identifying the bottlenecks correctly matters a great deal: if you are trying to fix Gnome or KDE performance by hacking around in X, you are mostly wasting your time.
The only thing on the X server side that will help a lot is the RENDER extension, because the RENDER extension for X is eliminating the need for Gnome and KDE to emulate graphics primitives client-side.
Yeah.. maybe they would have been better off inventing a special toolkit all for themselves.
*ducks and runs* Sorry! Couldn't resist!
How does the system know where the binaries are if you put them in application specific directories? This is one of my huge gripes with windows, you can't just type a program name in the run dialog and expect it to open (unless you add each and every program directory to your path). /etc Then I can back it up in one fell swoop. Having it all scattered would blow goats. Having to go to 8 different directories to change configuration files.
I love the fact that I can run any program just by typing it's name. Usually faster than hunting for it in a menu. And its great to have all configuration in