Slashdot Mirror
The State of X.Org
An anonymous reader writes "Phoronix has up an article looking at the release of X Server 1.4.1. This maintenance release for X.Org, which the open-source operating systems depend upon for living in a graphically rich world, comes more than 200 days late and it doesn't even clear the BugZilla release blocker bug. A further indication of problems is that the next major release of X.Org was scheduled to be released in February... then May... and now it's missing with no sign of when a release will occur. There are still more than three dozen outstanding bugs. Also, the forthcoming release (X.Org 7.4) will ship with a slimmer set of features than what was initially planned."
From the article:
"[Regarding the 'cloud,'] ownership was what made America different than Russia." -- Woz
Probably the complexity of the issues involved, and the ever-expanding environmental requirements X is being written for.
If you haven't been down-modded lately, you aren't trying.
Sacred cows make the best hamburger.
Live today, because you never know what tomorrow brings
It's not that they missed their date because they were busily fixing bugs and adding new features; they missed it because they're just not doing that much right now. There's no management, there's very little direction, and there's really not that much going on at all. That's not a good thing.
Internally, X11 running in local mode works the same way as Apple's window server - using shared memory and local sockets. Hell, even Windows Vista works this way (except using Windows IPC mechanisms instead of Unix ones).
Everyone who suggests changing the architecture of X by removing network transparency is arguing from a position of ignorance. There isn't a faster mechanism for doing a GUI server without either building the windows server into each app (allowing only one app at a time), or building the window server into the kernel (bad idea).
No windowing system has anything resembling widgets on the server-side. It's all done in client-side libraries, where that kind of stuff belongs. The server-exposed interface just provides the mechanisms needed for implementing widgets. That part is fine and doesn't need to change.
As for the protocol, only a few parts are actually poorly designed. Grabs need to be reworked as they can result in subtle race conditions and lock-ups. There's a lot of old cruft that nobody uses that could go away, but isn't really causing a problem by remaining in the protocol. The main historical problem was Xlib, which did a lot of stupid things with the protocol, resulting in reduced performance, especially over the network. XCB fixes that, although no toolkits have been ported to pure XCB yet (and it may be a while).
Ultimately what's going to be happening is the move towards Composite/EXA, OpenGL and DRI(2) for everything, which should negate a lot of the existing problems with X's rendering infrastructure. Again, the lack of manpower is going to prevent these projects from making much forward progress.
Geez, people bash on the network transaprency all the time, while it's actually the least of the problems. And it's completely irrelevant when an application connects locally because it happens over a shared-memory IPC (which unix sockets actually is, despite having "sockets" in the name).
I'd say all the old, device-dependent xfree86 code is to blame for most of the needless complexity and while it is being rewritten, it's a slow process that requires more developers than are involved with the project. Working with the new X.org code, while still demanding, wasn't really bad, just required thinking and getting "the bigger picture" well.
Actually, the new code is perfectly capable of dropping network transparency, integration of needless extensions and so on *when it's appropriate*, just take a look at Kdrive. But still too many important things remain in the xfree86 part.
This is Slashdot. Common sense is futile. You will be modded down.
Three main trends got X to where it is.
1) Proprietary hardware. NVidia and ATI didn't release specs. That resulted in what little dev talent there was being used to do reverse engineering. ATI has gone a long ways towards fixing this.
2) Insistence on cross platform support. Cross platform support means no device drivers - everything in user space. There are all kinds of security issues with everything in user space. This also mean no integration with the underlying kernel. OOPS isn't visible, VT interaction, mode setting, no intergration with framebuffer, etc. Insistence on cross platform means that one OS can prevent progress from occurring on the others. There seems to be some movement on this issue.
3) Failure to endorse OpenGL-ES as the core driver system. The embedded world went OpenGL-ES and ignores X (N810 is an exception). There is money in the embedded world and not in the desktop. The money went to OpenGL-ES.
From a developer's point of view the architecture of X has not evolved in a way where a developer can work on one chunk of the code without having comprehensive knowledge of the entire system. Requiring that level of knowledge really reduces the number of potential developers. Finally there is a giant amount of NIH that goes on.
http://www.mhall119.com
[...]
For "desktop linux," I don't see why the system isn't reworked to run off of a frame-buffer and scrap all the X crap -- still keep X for running networked apps. X uses multiple communications channels. There's TCP and DECnet, used for apps running on a different machine than the display server, and there's Unix pipes, which provide much higher throughput for local apps. But Unix pipes are nearly legacy now, because most servers also support MIT-SHM (the MIT Shared Memory extension), which lets an app have direct access to the X server's graphics buffers, and GLX (the OpenGL extension), used for running 3D graphics over a network. Finally, there's VirtualGL, which is a layer that can be used on top of either X11 or VNC. (See http://en.wikipedia.org/wiki/VirtualGL for more info.)
X11 already provides desktop Linux with you need to run high performance graphics.
Nothing for 6-digit uids?
that was the point of the fork though. Xfree86 developers moved slowly before X.org was formed, and wouldn't introduce changes like 3D accelerated desktop, period.
Developers where complaining about xfree86 for years before the fork, When the license changed it was just enough to push the fork. X.org began a long boring process of breaking X into smaller modules which will accelerate overall development. The problem is that process is still on going, and will take a few more years before any major upgrades can take place.
Think about the Mozilla project. They spent years cleaning out the core codebase and upgrading the core gecko engine from Netscape before they even had a decent beta. X.org is doing the same to something far larger, and uglier.
i thought once I was found, but it was only a dream.
I would like to contribute to the X, but mostly what stops me is that the code is written for the 80s. Lots of internals are using macros and bit values and optimization hacks, and directly 'speaking' X11 protocol. The code is disorganized, with files in weird locations and with two-letter names. I'm not blaming the developers, because in the 80s this is what had to be done. And they are making huge progress making it modular and organizing the code. But it's still not an attractive codebase to dig into.
Then, once you have decided to work on it and have fully absorbed X11 protocol into your being, you basically need a vmware license in order to develop. It's almost as hard to try out the changes you made as it is for kernel developers... slightly easier, especially for debugging, but you still need to either shut down everything you are doing to run a new build or have multiple development systems.
So basically it is a really step hill to overcome just to start developing X. Perhaps steeper since the kernel at least has excellent, 'simple', modular code to work with.
You can safely run more instances of the Xorg server on linux - just start on another screen (ex. Xorg :1). It's just that easy - the server will run in another
virtual console. If you know you made changes that could lock up your screen/keyboard,
you could conveniently schedule an at(1) process to kill it after 2 minutes (or
ssh into the box from another machine).
And if your messing with video card driver code, then again vmware won't be of any use. Unless you're working on the special driver for the vmware virtual video card itself.
And finally, at least for debugging and testing purposes, qemu (which is free) works just as well as vmware.