There's no right way to do it, only ideas that are better than others in certain situations. But if you had the opportunity to head up the design of a new OS, one to Put Things Right, one that could be radical enough to varnish out those UI/X bumps that have clung on for years, but practical enough to be used every day, what would you design? How would you handle application management? What about file types and compatibility? Where would you cherry pick the best bits from other OSes and where would you throw away tradition? I've tackled this challenge for myself and present (an unfinished idea): KrocOS(warning: HTML5 site, will display without CSS in IE/older browsers). OSnews Asks: What would make your perfect OS?

Nothing would have to be "installed". They will all be standalone applications. The applications should have a specific file which will be indexed by the OS so that it knows that its an application.

Everything should be possible from a keyboard shortcut - shutdown, etc. Kinda like quicksilver.

And it should be aesthetically beautiful.

A lot of applications would be included by default, like pdf reader/editor, a decent graphics editor, office.

Files will be arranged using tags. If a folder is given a "tag" all files within it will also get that tag. Similar to GMail. This is because a lot of times I have same type of file (say presentation files) in different projects (say different courses). Sometimes, I want to see all presentation files I have, sometimes, I want to see all files for a particular course.

Tags and other meta data should be at file-system level. Reiser4 was an attempt to do this right.
How do you read your Nepomuk data in 5 years from now? What's about backup? How to use the tagged files on another system, via network, etc?

Nothing would have to be "installed". They will all be standalone applications. The applications should have a specific file which will be indexed by the OS so that it knows that its an application.[q]

Allready done in Os X.

[q]
Files will be arranged using tags. If a folder is given a "tag" all files within it will also get that tag. Similar to GMail. This is because a lot of times I have same type of file (say presentation files) in different projects (say different courses). Sometimes, I want to see all presentation files I have, sometimes, I want to see all files for a particular course.

A perfect operating system? That is an interesting question. http://binagupta.sulekha.com/mstore/binagupta/albums/default/450px-... Hmmm let me think. I would say one that can run almost any program you throw at it. One that is not vulnerable to viri or Trojans, one that is modular, one that is easily customizable, one that is always fast, one that you do not have to wipe your hard drive and reinstall every 3 months, one that is updated every six months or so, one that is very user friendly, one that has a worldwide community of users who are invested in making it better and helping those new to it, one that can be used on the oldest of desktops, one that you can put on a memory stick ant take with you, one that is cutting edge ALWAYS and finally one that is free.

I'd just fork the Linux kernel, add a standard driver abi so they don't need updated anymore, ship with a minimal desktop, and kill dependencies forever. All software you get will be one file that already contains dependencies (the security isn't necessary for an average user anyway, it just makes them suffer when they need something not provided by their distro.). Then all annoyances would be solved and it would actually have a chance. And throw in an X replacement somewhere in there.

ChromeOS won't be using X and it wouldn't surprise me if they freeze the kernel as well.

People have been criticizing the lack of a stable abi, library dependency issues and X for over a decade and yet some Linux advocates still mod down people for daring to question these obviously flawed aspects of Linux.

OSX has proven that Unix can do away with the 70's dependency system, provide a stable abi and be successful desktop OS. Maybe Linux advocates should take a lesson.

Linux is open source, which means that everybody can do whatever they want; there is no central authority. Therefor, most of your point is silly. Some points I do agree on are that it would be nice to replace X, have a stable ABI for userspace programs, and get rid of dependencies for user-oriented applications (i.e. a web-browser, but not Apache).

However, a stable ABI for drivers would be extremely bad. I love open source, but I understand that there are valid reasons to create closed source/commercial software. However, there is no reason at all why a driver should be closed source. It simply doesn't make sense. Closed source drivers are less secure, hold back progress in the kernel, and make reduce portability. The only reason for closed source drivers that is even at all close to being somewhat valid is to protect IP. But that really only applies to graphics cards. And even then, I imagine it's just nVidia being lazy.

Please be more specific as to which points you find silly, especially in the context of design decisions made by Apple engineers when they built OSX.

As for the stable abi which Windows, OSX and Solaris all have...

hardware companies prefer to have a stable abi. They would prefer to not open their source and be able to provide a binary driver that lasts throughout the lifetime of the OS, or possibly even through two.

The reasons behind this preference are irrelevant. It doesn't matter if they really have ip to protect or if they do so out of voodoo superstition. It doesn't matter because they make the hardware that users want.

Even more significant is that there are only a few video card companies which means they don't need 1% of the market to make a profit. There isn't a financial incentive to cater to Linux users.

You can build a kernel designed to appeal to hardware partners or you can build it around ideology. Linux has chosen the latter and we have all seen the results. Linux gets treated like an unwanted stepchild by NVIDA and ATI. Of the support they provide they only exert minimal effort. OpenSolaris has a fractional share of Linux and yet there are many cases of it working better with Nvidia video cards.

It isn't just about video card drivers, there are wireless card and printer companies that hate supporting Linux as well.

Disallowing binary drivers makes a platform unappealing to hardware companies. The reasons why are irrelevent. They make the hardware, it's their preference and kernel developers can either choose to meet this preference or work against it.

It isn't about closed sourced drivers it is about lack of stability in how drivers interface with the kernel.

The problem is that devices that worked that worked a earlier kernel version are broken with a later kernel version .... because the way the drivers interface has changed .... this frustrates developers (whether it is closed or open development) because they have a moving target to develop to and frustrates users because things "don't work" anymore. Remember smaller companies have don't have infinite resources and somebody has to work on writing and supporting a driver.

Nvidia has flat out stated that they don't want to open the core of their driver.

Some companies don't want to open source their drivers because they don't want unsupported drivers floating around. They don't like the idea of someone running Joe Schmo's modfied driver and then calling the company when something goes wrong.

But as I said before the reasons are irrelevant. Hardware companies prefer to provide binary drivers that last throughout the life of a system. Linux devs can choose to work with this preference or against it.

Linux is open source, which means that everybody can do whatever they want; there is no central authority. Therefor, most of your point is silly. Some points I do agree on are that it would be nice to replace X, have a stable ABI for userspace programs, and get rid of dependencies for user-oriented applications (i.e. a web-browser, but not Apache).

However, a stable ABI for drivers would be extremely bad. I love open source, but I understand that there are valid reasons to create closed source/commercial software. However, there is no reason at all why a driver should be closed source. It simply doesn't make sense. Closed source drivers are less secure, hold back progress in the kernel, and make reduce portability. The only reason for closed source drivers that is even at all close to being somewhat valid is to protect IP. But that really only applies to graphics cards. And even then, I imagine it's just nVidia being lazy.

I can't do it without hiring a bunch of programmers, and I don't have the money to do that. So it doesn't really matter whether it's open source or not; all that matters is who the money is currently going to, and they've already spoken on how they love it the way it is.

Also about the drivers, it's not the OS vendors place to criticize 3rd parties, they need to be doing all they can to make all stakeholders jobs easier (including hardware vendors). As for compatibility, all of my vista drivers work on 7, doesn't matter that their closed source as long as they work is all most users care about.

In terms of Linux based platforms, the OS developers are doing all they can to make it easier for hardware manufacturers. Kernel and Xorg folk will write the drivers taking development costs away from the vendor. The linux driver project provides a point of contact for hardware manufacturers rather than them having to figure out if they talk to Linux, Xorg, Alsa or some other project that provides direct hardware support.

Free platform support in exchange for the minimal interface specs to write drivers against; how much easier for the hardware vendor can it get? This is like your neibour saying; "point out where the endge of your driveway is and I'll shovel the snow out of it each morning while I'm doing mine" - 'I'm sorry, that's too complicated, I'll keep shoveling my own driveway."

It's completely unrealistic to think that they will continue to maintain every driver in existence for Linux, and that the ones they do will always work perfectly for every release. It could still be argued that having people continually update drivers instead of just being able to use the same ones is a waste of resources.

We should be so lucky as to have interface specs overwhelmingly provided by hardware manufacturers.

Aren't driver issues now managed like a bug found anywhere else in the kernel source tree? The glut of hardware supported natively in the kernel is staggering even if it's not 90% of desktop latest hardware.

I still like the example of Creative who started an open source X-FI driver then chose to hand it off to Alsa with full documentation. When they lost interest in the project, they performed a project lead's final duty; find a new project lead to carry on.

As for compatibility, all of my vista drivers work on 7, doesn't matter that their closed source as long as they work is all most users care about.

Because Vista and Win7 have very similar software stacks. I know that certainly wasn't true with the XP-to-Vista transition; I interned with the County Governement in undergrad, and I was there when they moved from XP to Vista for many of their machines. There was a sizable minority of devices and programs that we just could not, for the life of us, get to work with Vista (or that caused unreliable behavior, or could crash the system -- thanks, Norton AV). And "devices" is not just graphics cards; it also included, right off the top of my head, a number of parallel-port printers.

However, a stable ABI for drivers would be extremely bad. I love open source, but I understand that there are valid reasons to create closed source/commercial software. However, there is no reason at all why a driver should be closed source. It simply doesn't make sense. Closed source drivers are less secure, hold back progress in the kernel, and make reduce portability. The only reason for closed source drivers that is even at all close to being somewhat valid is to protect IP. But that really only applies to graphics cards. And even then, I imagine it's just nVidia being lazy.

A stable abi is not the same as closed source (!)

Drivers are one of the most nasty, buggy and system dependent pieces of code that one can write. There are so many testing what if's and maybe's involved that it is horrible. Every time you change the interface of a driver (class) you need to test not just that driver but also the drivers interaction with all possible combination's of other drivers / hardware.

The Linux kernel developers are delusional of their own capabilities to such an extent that they think they can change driver interfaces and release the code without testing. In a given iteration 90% or more of the code never gets tested and the small part that actually gets tested doesn't work, this is labeled "regressions" and each release has a number of these.
A stable abi would be the first step on the way to a more systematic testing framework for the kernel and related drivers.

Part of the issue claimed by some NIC providers was patent related and/or regulation related. For example, an open NIC driver allows the owner to modify it changing the broadcast strength of the NIC radio (wifi). You can push it's power output beyond what is allowed by regulations for that class of radio. Given the availability of signal extenders, this reason doesn't hold a lot of validity in my opinion.

Some device drivers include the firmware rather than it being loaded on a flash chip on the hardware. The claim here is that providing driver source is not possible because they can't allow access to the bundled firmware. For this one I ask; is it really that much harder for the driver update wizard to push firmware updates into a nand chip on the given board?

I've also yet to hear why these "secret sauce" built hardware components can't simply provide a generic driver interface and hide the state secret hooks in the chips behind it. (GPU is a good example)

The claim that competition can read the drivers and copy them carries a bad smell also. If your competition is waiting for your next hardware release before starting development of a competitive device; they are not competition. They're not likely to be in business very long either. On the other hand, would this not motivate faster advancements in technology? Older generations drop into consumer budget ranges faster while newer generation's profit supports development on the next board to come out. (yeah, I know, that would benefit tech and the consumer far more than the shareholder profit margins.)

Bit of a rant but my original point was that it's still very wide spread beyond GPU. Wifi NIC are probably second on the list for most people. (has broadcom gotten any better?)

A stable ABI will kill the open source Linux kernel in short order (I'm betting on ~5 years). It will guarantee that in the future your drivers are closed source. Maybe you don't care, but I do and the kernel developers do.

X is not the problem. Replacing X doesn't solve any problems and introduces a slew of new ones. There are few good reasons to replace X and a large number of reasons not to replace X. I'd love to hear why you think X is an issue so I can see if you fall in to the 90% of the anti-X camp that just doesn't know what it's talking about.

OS X works as well as it does almost entirely because it is a single vendor system. Linux distributors could do exactly the same thing. It is not a technology issue! The fact is that distribution makers don't want to do that level of integration (or at least they don't do it) and Linux's users would punish them with their feet if they departed so radically from the status quo.

I had high hopes for Ubuntu once upon a time, but they fell in step (in the end) with every other distribution in any number of ways.

I will repeat it once more for the tl;dr crowd: If you want Linux OS X you can build it 99% out of existing software available for Linux right now. Form a company, build boxes with a specific set of hardware, build your distribution, use app bundles. It can work! Today. Without replacing X, or changing the kernel.

If you have a small enough target even the unstable binary ABI is not an issue. If vendors only need to target one new kernel per year (at most) then there is no problem.

X is not the problem. Replacing X doesn't solve any problems and introduces a slew of new ones. There are few good reasons to replace X and a large number of reasons not to replace X. I'd love to hear why you think X is an issue so I can see if you fall in to the 90% of the anti-X camp that just doesn't know what it's talking about.

I agree completely. It's become kindof a motto for the Linux Hater's Club around here: "X Is Old, X Is Bad, X Is the Problem!" It's basically just a sizable group of people saying the same thing over and over again, and hoping that having it endlessly and oft-repeated makes it meaningful.
X isn't perfect, but it's improving, and it's becoming pretty damned good. It's come a loooong way from several years ago.

OS X works as well as it does almost entirely because it is a single vendor system. Linux distributors could do exactly the same thing. It is not a technology issue! The fact is that distribution makers don't want to do that level of integration (or at least they don't do it) and Linux's users would punish them with their feet if they departed so radically from the status quo.

That's quite true. There's enough common hardware that's well-supported in Linux that, at least in theory, you could have a vendor start shipping tuned-for-linux systems that'd be about as reliable as OS X is now. Well, almost: the 3D stack is still a little quirky, but, excepting that...

I agree completely. It's become kindof a motto for the Linux Hater's Club around here: "X Is Old, X Is Bad, X Is the Problem!" It's basically just a sizable group of people saying the same thing over and over again, and hoping that having it endlessly and oft-repeated makes it meaningful. X isn't perfect, but it's improving, and it's becoming pretty damned good.

So I guess Apple and Google are in the X hater's club too, right? Thom is in there too lol. You must be pretty deluded to believe that all this hatred is baseless or exaggerated.

X was built with poor design descisions that cannot be blamed on the typical excuse of buggy video drivers. There are plenty of cases of X crashing that show this.

A stable ABI will kill the open source Linux kernel in short order (I'm betting on ~5 years). It will guarantee that in the future your drivers are closed source. Maybe you don't care, but I do and the kernel developers do.

Maybe you should explain how that would happen, there's no reason having to download a driver from a third party or shipping them separately from the kernel will kill it. And how exactly will the demand for an operating system running millions of servers vanish? I can only guess you think that all drivers have to shipped with the kernel, or some other similar logical flaw.

It's a simple process. Once commercial companies have a stable target, they target it. They stop releasing hardware specs. People use their drivers because such drivers exist, greatly driving down demand for a Free replacement or for enhancements to a Free version.

Repeat.

After a while you will clearly have *most* drivers for *most* hardware be proprietary. Linux, at this point, becomes fairly useless without such third party drivers... drivers distribution vendors probably cannot ship themselves (or, if they can, joe random hack-my-own-distro developer can't). Think the old nvidia redistribution problem for every single piece of hardware.

You cannot assume that companies will all do what nvidia (eventually) did and permit redistribution by anyone.

This is not certain, but it's certainly likely. Arguments like "It hasn't happened to $FOO, which has a stable driver interface" do not necessarily apply. Most Free operating systems do not have nearly the level of corporate interest that Linux has.

What Linux really needs is an improvement to workflow involved in getting and loading out of kernel drivers. That would solve most of the problems people actually want solved without any of the drawbacks.

It's a simple process. Once commercial companies have a stable target, they target it. They stop releasing hardware specs. People use their drivers because such drivers exist, greatly driving down demand for a Free replacement or for enhancements to a Free version.

Repeat.

After a while you will clearly have *most* drivers for *most* hardware be proprietary. Linux, at this point, becomes fairly useless without such third party drivers... drivers distribution vendors probably cannot ship themselves (or, if they can, joe random hack-my-own-distro developer can't). Think the old nvidia redistribution problem for every single piece of hardware.

You cannot assume that companies will all do what nvidia (eventually) did and permit redistribution by anyone.

But all that stuff's only a problem when you're dependent on repositories. There's no reason someone couldn't look up the specs of their computer an download it directly from the vendor, this is a one time annoyance that anyone who has installed a clean version of windows has dealt with, and no one complains about.

And there isn't any real demand for "free drivers", it's all about drivers that work is all they care about. And you seem to have made up this "driver distribution vendor" there's the OS vendor, the user, and the hardware vendors, nothing else. Having to download drivers from hardware vendors, and having them work without special settings is a completely acceptable compromise. Any vendor that wants to sell their product to the market will undoubtedly allow the driver to be shipped with the operating system, especially if it becomes apparent that it's market share will significantly rise. The idea that somehow people will stop working on the kernel because only proprietary drivers are available is completely baseless, a lot of average users buy a computer and never need to know what a driver is anyway.

Hardware specs don't matter either, the hardware vendors have to stay competitive and make the drivers exploit the full potential of their products. Having the hardware specs for something like a wireless adapter might make it possible to add wpa to an old card or something, but really would just be delaying buying a new piece of hardware. Right now they have no incentive to write good drivers because of the small market share.

But all that stuff's only a problem when you're dependent on repositories. There's no reason someone couldn't look up the specs of their computer an download it directly from the vendor, this is a one time annoyance that anyone who has installed a clean version of windows has dealt with, and no one complains about.

No. Vendors generally do not provide their specs for download. You can download drivers for Windows, or spec sheets, but not specs. Not the information you'd need to write a driver.

And there isn't any real demand for "free drivers",

This is the heart of the matter, which I addressed in my original post. You may not care about free drivers, and I know the people wanting a stable driver API don't, but I do and the kernel developers sure do. This is entirely about free drivers.

If you want to be honest and rephrase your position as "I believe Linux should have mostly binary-only proprietary drivers and we need a stable API to allow that to happen," then that's fine, but you will see little support from the free software community. Linux exists largely because of people who care about Free software with a capital F.

And you seem to have made up this "driver distribution vendor" there's the OS vendor, the user, and the hardware vendors, nothing else.

Have you ever actually used Linux? There's the OS vendor, which is Linus and cohorts, the hardware vendors, and the Linux distributions, who, in order to provide a system that actually can install, have to ship drivers with the install CD. If the drivers are Free this is no problem but if the drivers are non-Free they would require an agreement with the driver author--namely the hardware vendors. This causes many problems, not the least of which is that it prohibits Joe-Random-Me from rolling a distribution.

Having to download drivers from hardware vendors, and having them work without special settings is a completely acceptable compromise.

Nobody cares where you download your drivers from. As I said in my original post, having a better process for installing and loading out of kernel drivers is what Linux really needs. What is a problem is when those drivers are proprietary.

Any vendor that wants to sell their product to the market will undoubtedly allow the driver to be shipped with the operating system, especially if it becomes apparent that it's market share will significantly rise.

In your optimistic opinion, sure. In my pessimistic opinion, no. I am certain that even if *some* companies do allow redistribution not all will (they will not be required to, so they wont) and that means unsupported hardware at install time. Like, you know, your network card. Can't get the vendor's site now!

The idea that somehow people will stop working on the kernel because only proprietary drivers are available is completely baseless, a lot of average users buy a computer and never need to know what a driver is anyway.

I never said that people would stop working on the kernel altogether, although eventually it could happen. I am talking about a disincentive to write replacement Free drivers for proprietary drivers that already exist. If you think this doesn't happen you have only to look at existing Linux driver history to prove otherwise. Only the strong pressure to get drivers in-kernel has been enough to incentivise the creation of replacements thus far.

Hardware specs don't matter either, the hardware vendors have to stay competitive and make the drivers exploit the full potential of their products. Having the hardware specs for something like a wireless adapter might make it possible to add wpa to an old card or something, but really would just be delaying buying a new piece of hardware. Right now they have no incentive to write good drivers because of the small market share.

What? First you say specs don't matter, which is blatantly untrue as without specs Free drivers are fiendishly difficult to write. Then you admit that hardware vendors don't care to write good drivers because the market doesn't require it. This seems like a strong argument to not leave it up to them!

It's a simple process. Once commercial companies have a stable target, they target it. They stop releasing hardware specs. People use their drivers because such drivers exist, greatly driving down demand for a Free replacement or for enhancements to a Free version.

You ignored his question. He asked how a stable ABI would kill the kernel, not reduce the number of open source drivers. Oddly enough, Microsoft is able to keep advancing their kernel, despite the fact that their ABI is relatively stable.

"It's a simple process. Once commercial companies have a stable target, they target it. They stop releasing hardware specs. People use their drivers because such drivers exist, greatly driving down demand for a Free replacement or for enhancements to a Free version.

You ignored his question. He asked how a stable ABI would kill the kernel, not reduce the number of open source drivers. Oddly enough, Microsoft is able to keep advancing their kernel, despite the fact that their ABI is relatively stable. "

And you cannot see how the Linux kernel will be a non-starter if its drivers cannot be legally distributed with it? Assuming some kind of shim ala nvidia is used to bypass the GPL problem you still have to have agreements between each and every distribution vendor and each and every hardware vendor, or open distribution offers from the hardware vendors. This is an untenable situation and will lead to a decline in the usefulness of Linux.

And you cannot see how the Linux kernel will be a non-starter if its drivers cannot be legally distributed with it?

You're looking at this all wrong. Hardware manufacturers aren't at war with Linux. They want a symbiotic relationship with OS developers that allows them to sell as much hardware as possible and protect their intellectual property. Microsoft has been able to make this work because they provide a stable driver platform for the hardware manufacturers to work with, and Microsoft doesn't require that they disclose their secret sauce, as you clearly want them to do. Hardware manufacturers *want* to ship drivers with your distros. They really do. But you're making it impossible -- or, at best, extremely difficult -- for them to do it by constantly shifting the ABIs and thus requiring source code disclosure.

Let me ask you something: If you find yourself doing something over and over again, and things aren't getting better, should you keep doing the same thing again and again (and repeat the same mistakes), or should you try something different? I would argue that Linux is going to get far better driver support if it accedes to the business requirements of hardware manufacturers and works with them.

I do understand that there are many people who prefer to look at this issue through an ideological lens, but I don't think it's reasonable to make all-or-nothing demands of hardware manufacturers without giving anything back. Give them a stable ABI. Allow them to ship binary drivers and protect their intellectual property. If you did this, the whole issue of not being able to play DVDs, not use the latest graphics hardware, and many other issues would simply disappear, and level the playing field with Windows.

But I fear that that won't happen, as long as you listen to people like Stallman, who really don't care about commercial interests.

"It seems like I am forever repeating myself. Once more! A stable ABI will kill the open source Linux kernel in short order (I'm betting on ~5 years).

How will it kill the kernel? A stable abi would bring in better driver support which would bring in more Linux users.

Why are you so worried anyways? The Linux desktop has been in a coma for over 10 years, I'm not sure why you are so concerned with death when desktop Linux just sits there and drools on itself.

I'm really gonna laugh if an alternative like Haiku comes along with a stable abi and trumps Linux on the desktop. Defenders like you will have helped save desktop Linux from its own success. "

Who said Desktop Linux? I said Linux, the kernel itself, meaning all Linux.

If Haiku beats Linux on the desktop I will applaud. Free is Free. But, Haiku won't win because of its stable driver interface. It will win because of consistency, integration, etc, etc.. Things users actually see. If there were one desktop and one look and feel on Linux, with a single target for the menu, file locations, etc, etc then Linux would be having an easier time, too.

Desktop Linux has many, many problems that need solutions in order for it to succeed. A stable driver ABI is not essential and won't make a significant difference in user experience.

The no stable driver ABI is brought up again and again as the reason that Linux is not succeeding on the desktop. However the people who make this argument fail to give any evidence that this is what is holding linux back. I've yet to see any company saying that the driver ABI is a serious problem for them. To the contrary the NVidia guys said in a recent interview that it's not much of a problem, and they are probably the most relevant provider of closed source drivers for linux. Similarly if the driver ABI is the main thing holding linux back, how come that Opensolaris hasn't overtaken Linux in popularity and why is it that Opensolaris has a lot less hardware support than Linux? (Note I'm not criticising Solaris, I think more open OS are always good).

The no stable driver ABI is brought up again and again as the reason that Linux is not succeeding on the desktop. However the people who make this argument fail to give any evidence that this is what is holding linux back.

The evidence is staring you in the face, but you don't want to hear it. Why can't the vast majority of distros do something as simple as play DVDs or Blu-Rays without being sued? This is 2009, for chrissakes. How can you possibly call that success?

The primary reason for this failure is the insistence of Linux zealots on having source code for anything they ship. Constantly shifting the ABIs isn't rational, from a development perspective. People claim they want "flexibility", but that's a red herring. What these same folks really want is to create a binary incompatibility such that you would HAVE to have the source code and compile the drivers with that specific version of the kernel in order to have a prayer of working.

Hardware OEMs aren't going to disclose all of their secret sauce to open source developers. Just as they won't share all of their IP with Microsoft. It's not a trust or fairness issue. It's a trade secret and patent issue. If you give away your technological advantages to your competitors, you cease to offer differentiation -- and you die as a commercial entity. Your competitors can leverage and replicate your research without putting in the same level of investment. You know, I'm surprised that so many people in the FOSS community are either blissfully unaware of the realities of this situation -- or simply don't care. Either way, you're shooting yourselves in the foot. It's like you're afraid of success or something, even when people explain step-by-step how you can win.

As for me, I don't care, one way or another. I write commercial software for a living, and the fact of the matter is that, if you guys fail to solve this problem, it just means more business for me. So, by all means continue to ignore what I'm saying. Enrich me, please.

Similarly if the driver ABI is the main thing holding linux back, how come that Opensolaris hasn't overtaken Linux in popularity and why is it that Opensolaris has a lot less hardware support than Linux? (Note I'm not criticising Solaris, I think more open OS are always good).

First, OpenSolaris hasn't been open very long. Linux has had more than a decade headstart, and being first means a lot. Some people refer to this as First Mover Advantage. It takes time to write drivers, and there has to be sufficient interest and motivation to target any OS. Second, no slight to OpenSolaris (it's a good OS), but it was derived from Sun's relatively expensive workstation and server OS codebase which didn't use horizontal market hardware. Somebody has to write those drivers. Comparing one form of failure against another is counterproductive.

The evidence is staring you in the face, but you don't want to hear it. Why can't the vast majority of distros do something as simple as play DVDs or Blu-Rays without being sued? This is 2009, for chrissakes. How can you possibly call that success?

What has any of that got to do with a stable or changing kernel ABI? Oh yes, nothing. What conversation do you think we're having here?

The primary reason for this failure is the insistence of Linux zealots on having source code for anything they ship. Constantly shifting the ABIs isn't rational, from a development perspective. People claim they want "flexibility", but that's a red herring.

I find this laughable. Firstly, I have a pretty good idea why Linux is failing on the desktop and it has nothing to do with an 'insistence' on Free software. Distribution vendors routinely ship non-Free software when they have a good reason to do it... and a workable agreement with the rights holder.

Second, if shifting ABIs isn't rational why is it done? Yes, I know what you're about to say:

What these same folks really want is to create a binary incompatibility such that you would HAVE to have the source code and compile the drivers with that specific version of the kernel in order to have a prayer of working.

So now it's a conspiracy! The fact is that kernel devs do want the source code to drivers written for their kernel. The GPL requires this without any shifting of ABIs. This is, in fact, the rational argument against my argument that a stable ABI helps proprietization of the kernel. It's amazing no one has attempted it.

So, given that we get the source code anyway, why do you think there isn't a stable ABI? Could it be that there is some rational reason not to have one?

Hardware OEMs aren't going to disclose all of their secret sauce to open source developers. Just as they won't share all of their IP with Microsoft. It's not a trust or fairness issue. It's a trade secret and patent issue.

This is simply not true. They will disclose that information if that's what it takes to sell hardware. Their business wont die if they do, it may if they don't.

some stuff on opensolaris

I for one welcome our new OpenSolaris overlords. If what you say is true it should gradually take over from Linux. If it does I will owe you a caffeinated drink of your choice.

What has any of that got to do with a stable or changing kernel ABI? Oh yes, nothing. What conversation do you think we're having here?

Source code. FOSS zealots insist on having the source code for everything that they distribute -- drivers, media players, etc -- and having an unstable ABI is a perfect illustration of how they force that to happen. Content owners don't want to make media playback possible without DRM--and they're not going to allow the DRM-related code checked into the Linux tree. Result: Epic fail for Liux distros. They can't even play a damned DVD or Blu-Ray with a default install.

I find this laughable. Firstly, I have a pretty good idea why Linux is failing on the desktop and it has nothing to do with an 'insistence' on Free software.

See above. Tell me how that is a better experience for users. I'd love to hear your response.

Distribution vendors routinely ship non-Free software when they have a good reason to do it... and a workable agreement with the rights holder.

They ship commercial software because it includes things that people want -- like basic DVD playback, etc -- that can't be included in Linux without a license. And since the FOSS zealots have an ideological problem with DRM -- thus causing them to ignore basic & reasonable customer requirements -- the result is epic fail.

So now it's a conspiracy!

More like a confederacy of dunces.

The fact is that kernel devs do want the source code to drivers written for their kernel.

Duh. Ignoring market realities.

The GPL requires this without any shifting of ABIs.

The GPL does NOT prevent establishing a binary interface contract for the kernel ABI. Any suggestion to the contrary is ridiculous and wrong.

This is, in fact, the rational argument against my argument that a stable ABI helps proprietization of the kernel. It's amazing no one has attempted it.

So far, all that you've argued is that kernel devs like to have source code for their drivers. That's a pretty pathetic defense.

So, given that we get the source code anyway, why do you think there isn't a stable ABI? Could it be that there is some rational reason not to have one?

Continued idiocy is not a rationale for idiocy.

This is simply not true. They will disclose that information if that's what it takes to sell hardware. Their business wont die if they do, it may if they don't.

LMAO. Wrong. You guys keep prodding the hardware manufacturers to release specs about their hardware, and then you whine, wring your hands, and complain when they don't. You're like a dog chasing its tail.

I for one welcome our new OpenSolaris overlords. If what you say is true it should gradually take over from Linux. If it does I will owe you a caffeinated drink of your choice.

Apparently, you missed the part where I mentioned that Linux has had a decade headstart on OpenSolaris, and its forebear Solaris was primarily run on expensive workstation and server hardware, not widely available x86 desktop PCs. So, it's unlikely that it will ever catch up to Linux, for reasons wholly unrelated to the kernel ABI. But, by all means, feel free to erect another strawman and flog it, if it makes you feel better.

I would go for very social apps that make sharing of photos, files (audio, video, profiles etc) EASY and SECURE.
Something like Retroshare.sf.net would be a good basis for that ( already includes secure file sharing/messaging etc without the need for a server )
I would integrate Retroshare in all KDE apps, everything should be well integrated.

I would tune the kernel for desktop responsiveness and use BtrFS, which snapshots would be integrated into Dolphin/Konqi.

This would be perfect for anti-corporate paranoid privacy geeks like me.

Oh yeah and a webkit based browser with adblocking would be a must

When I think about it, it could be done today. Now I just need a few million$.

Edit: And updates would just install silently and I would rename a lot of apps. More like what Kroc is suggesting.. verbs and nouns, unless the app has a really good name (not like Firefox or Kopete etc.)

Extending BeShare to be decentralized/heavily encrypted would be a cool thing for someone to work on. My idea of a BeShare decentralized node would share all downloaded data plus download additional data to share when idle thus improving availability.

Cool thing about BeShare is it supports file atributes and searching just like BFS

And when you accept to install an update, it can still break the machine, so what’s the difference really when you boil it down? As long as the machine has auto-rollback features and the in-built ability to deal with update problems then not prompting to install only makes things simpler for all users.

I have grown to like X11 the ability to remotely run a program and have it show up locally is extremely nice... however I dislike its quirks and general bloatiness

I like how BeOS/Haiku handles files/folders except when it concerns the whole spatial idea which I find silly for instance I navigate into a folder to leave that folder. I have to close the window I find this extremely backward. Thankfully it is optional on Haiku.

I somewhat agree about debranding of apps however I think that is overrated and should be reduced to all apps should share a common file structure interface and not use proprietary protocols. Mail could point to iTunes or Photos to Gqview etc... that is what we have defualts for.

I also thing that hardware shoudln't be hidden but should be displayed in an informative manner for instance Haiku drive icons (optionally) display capacity as a bar. I think that if you separate the user too far from the computer you are undermining the usability of the computer for the sake of simplicity.

I think haiku is the closest at the moment to being an ideal desktop OS except for hardware support and document interoperability. Rootless X11 would be nice too and would probably help to cover document compatibility by allowing quick and dirty ports of Linux/Unix document apps.

What you mentioned about capacity is very true actually, something I had overlooked. But we do need to show this in a way that regular users will be able to understand and that power users won’t get annoyed at too.

Percentages / bars are not always a good way of showing it, because many users think that getting to 60% doesn’t leave them much _time_ left. They have no immediate understand of how much the capacity represents in time as they are used to progress bars and percentages moving very quickly. I always have to explain to users that 1. they have more space then they will ever use, and 2. As long as there’s at minimum 4-8 GB free, everything will be fine.

Yes, this is actually something that annoys the hell out of me about Vista's drive representation. It not only shows percentage, but it turns RED when you get below something like 20% free space, even if you still have 16GB free! I have seen people become convinced that they are too low on disk space, even though that isn't really the case.

I like how BeOS/Haiku handles files/folders except when it concerns the whole spatial idea which I find silly for instance I navigate into a folder to leave that folder. I have to close the window I find this extremely backward.

Try holding down the Option key while opening sub-folders. This also combines nicely with Command-Up/Down.

just use one of the more mature Operating systems out there.
I'd use VMS. Ok, I'm biased here as I first used it in '77. However, it works, has cluster uptimes including updates that are measured in years (17 is my record) and is pretty secure. Has had all the ACL's etc for over 20 years.

Can you expand upon your first point—I’ve designed this to avoid app bloat, so you may have misunderstood one of my points or I didn’t explain a particular aspect clearly enough (which is very understandable).

Well if there is no brand, then there can be only one web browser (for example), so the users will ask that this web browser include all the features found in FF,IE,Chrome,etc.
So this web browser will become bloated..

More seriously, applications evolve thanks to competition: look at FF, the developpers only started changing to a sane multi-process architecture when Chrome demonstrated the flaws in FF's architecture, how could there be competition in your OS if you allow only one web browser?

This thing called collaboration whereby if Google had an idea to add in multi-process capability to the KrocOS browser, they could—instead of making another browser so that they could call it Google Chrome, and advertise it on their site, and install it silently with other apps and all the very things I would try limit with KrocOS.

tags!? you mean like mimetypes which Haiku already has? or an extension of that? regex attribute based tagging? embedding application tag in the file attribute?

An extension of that, files would be tagged also by their package name and instead of storing files in hiearchical directies, you (or tools) would add your own tags much like photo/music aplications work but for everything.

Linux is as bloated as you want. That's how it fits into so many embedded environments. Try a different kernel then the generic one in the repository (for instance the Real Time Kernel). Or use a lighter distro. If that's still not enough compile you own kernel setup as you like it. Or even roll your own distro. ;-)

Responsiveness: take a real-time kernel or BFS for a spin. My desktop is generally more powerful than I need, but RT kernels, and now BFS, make up for everything but crappy X video playback on my notebook.

App startup: it's a PITA of a distro, but check out DeLi, sometime. Made to be really light to core (uClibC for IA32 )...OMGWTFBBQ start times.

Honestly, Linux is already mostly there. I love the degree of control I have over it, and the number of power-tools you get with a GNU userland.

Throw in some X stabilization and some long-term-stable APIs -- like driver APIs for the kernel, and maybe DE-neutral high-level windowing and sound APIs -- and you'd pretty much be there.

If I where to do this in perfect-world fantasy land, I'd use some kind of microkernel, with the ability to switch between multiple sets of userspace daemons to provide different personalities at different times to accomplish different tasks. Like, the same microkernel could drive different userspaces, to be a slim, fileserver here, to mimic a Windows userland over here, and to mimic a POSIX environment over here.

In the real world, tho, I don't really have any outstanding entries on my OS feature wish-list; bug-fixing, driver availability and some holy-war-resolving standardized API's would pretty much make Linux my perfect OS.

Every distro is designed with the assumption that all applications are open source. There's no standard installation package that will work across distros. There isn't even a standard program files or system icons directory.

Not only does it make Linux unappealing to proprietary developers but it's a waste of resources. An application should only be compiled once by the developer, not a few dozen distro maintainers.

Software distribution systems should be designed to work with both closed and open source. Proprietary software isn't going away, it's delusional to think otherwise.

But I guess some FOSS advocates prefer delusion to market share so expect Linux to however around 1% for yet another decade.

Provide a stable platform for developers and the apps will come in. Just look at how many game developers have flocked to the iphone. Programmers need to get paid and you can't sell support or services with a $3 game that has 8 hours of gameplay.

You might not care about cell phone games but that doesn't change the fact that when you dismiss proprietary developers you become unable to provide software that people want. Software that GPL programmers haven't been able to provide alternatives for.

If you want to see stagnation just look at Linux desktop marketshare since 1998.

But keep dismissing proprietary developers that are trying to earn a living, that seems to be a wise strategy. When trying to convert a new Linux user who asks about games just call them "fart games" and tell them that they don't actually need that.

You might not care about cell phone games but that doesn't change the fact that when you dismiss proprietary developers you become unable to provide software that people want. Software that GPL programmers haven't been able to provide alternatives for.

If you want to see stagnation just look at Linux desktop marketshare since 1998.

But keep dismissing proprietary developers that are trying to earn a living, that seems to be a wise strategy. When trying to convert a new Linux user who asks about games just call them "fart games" and tell them that they don't actually need that.

YouDontActuallyNeedThat(tm).

Generally, freetards will respond with:

-fck Visual Studio, VI and Emacs are soo much better, when you'll learn to use them, you'll be soo productive

-fck GUI, who needs GUI? I don't need GUI, I use links as web browser, I use ircII in text mode to connect to IRC and talk with other freetards; I don't even need to write C++ apps, cus I write suuuch powerfull bash scripts in Emacs, and anyway, python rocks; I use latex and I'm soo much productive and I'm free and I don't want to use software from proprietary pigs

-if you need GUI, you can allways use X; it's not X's fault for crashing, it's proprietary pigs's fault cus they don't provide open source drivers... so what if X is bloated, slow like hell, nobody is hurrying, and it really rocks cus I can use it over network when I'm sitting on toilet and write powerfull shell scripts on my electric toaster which runs Ubuntu Ziggy Zebra

"RTFM idiot", "it works as intended", "so what if it doesn't do what you want? either implement it yourself or stfu cus nobody is payed to do it", "maybe linux is not for you", "linux is not windows", "so what if it's crappy? it's free and freedom is better than performance", "open office death slowness and curruption of .doc files is MS's fault", "os is crashing because of Nvidia, nut because X cause X is superrior and foss", "it works for me", "you don't need that", "it works from time to time".

I don't really see what anything in that rant had to do with my post. I was talking about lowest-common-denominator APIs that both Gnome and KDE could implement, to allow for DE-agnostic GUI programming. I most certainly was not advocating some kind of universal package format. I don't really see how you could've gotten from one to the other, unless you just really wanted an excuse to complain about Linux.

Can you explain how, exactly, lowest-common-denominator high-level sound and graphics APIs directly implies either pervasively frozen APIs and ABIs throughout the system, or a common universal package format?

For me OS is only the way to use the software i work and have fun with, so i want to be independent - to install and use whatever software i want. Linux based OS are near with wine, so i prefer linux, but still lot of work to be done..

I like many of the ideas, especially 'no-brands', and making applications file-management based.

Some of these things are possible to do right now. For example, on my Ubuntu installation I never open programs, only files (with the exception of Chrome and Calculator, since they are not file based).

Rather than using File/Open, I find the file with the file manager and open it.

Instead of opening, for example, OpenOffice.org Word Processor to create a new document, I navigate the folder where I want the document created and create it using a template called "ODF Text Document" stored in ~/Templates.

For window management, I would love to see an easy to use tiling window manager: Each screen would be divided into two columns. Each column would be divided vertically into any number of frames. Each frame would have tabs that would contain windows. There would no necessary keyboard shortcuts (although they would still exist). The user could select an active column or frame that new windows would appear in. Applications could integrate with the window manager so that for example, a web browser would use the window manager's tabs, rather than having its own.

Well for me PCLinuxOS is about perfect. I would love to Amarok 2 work like it's predecessor, (some will hate me for this) a way to easily install Office without third parties and a Baseball game to play on Linux. This is my perfect desktop

OpenBSD is pretty near what I want in an OS, Simple, configurable and stripped down to only what is really necessary ... Once you learn how to use the tools provided properly. Takes a while to get your head around but once you got that sussed. Using any other of the BSDs or Linux just seems limited.

I would preferrably use OpenBSD with the Window Manager that IRIX used (4Dwm), and better SMP performance and 3D acceleration, would be nice ... but just having something to use as nice as the IRIX desktop would be nice, I don't get on with the 3 Big Desktop Environments.

I would love SGI to Open Source IRIX, I loved using it in the computer labs on the old O2 machines that used to smoke everything else. I doubt this will ever happen unfortunately.

- Total transparency for all processes. Like dtrace/system tap for everything + time machine, so you could ask what an app did one minute ago, what program changed a particular file & why ("why" as in see the call stack for the occurence). Impossible, but maybe someday... ;-)

I'd like to see a Plan 9-ish OS (very elegant) and for it to be public domain. That would mean that anyone could use any part of the OS - no having to "re-invent the wheel" just to get around license restrictions.

However, Plan 9's GUI takes some getting used to, so I'd make that much more user-friendly.

I absolutely agree - Plan9 is very elegant and it celebrates the "everything is a file" metaphor - unlike Unix systems where device drivers are special files (I always found that IOCTL stuff creepy). I think this is a good base...

Filesystem should be not Unix-Standard but more MacOs like - there was an article covering a FSH here on OSNews.

Well, regarding the GUI I think the old X should be retired. A ZUI as proposed by Jef Raskin based on OpenVG. This would eliminate the metapher of standalone apps and break compatibility with all current apps, of course.

I agree with most of KrocOS, but rapidly disagree with the amount of windows a *user* would have to *manage*. Window managers ought do their job-- I've thereby used wmctrl & devilspie to shove minor apps to the left 40% of my screen (with no window decorations) & keep the major ones on the right 60%. I prefer tablet/pen computing, and use mouse gestures for my maximize,minimize & corners with brightside & zenity-lists to open new apps, switch between apps (actually redecorates, shades & cascades) & show recent documents.

Otherwise, I see all 'files and folders' as libraries with tags (yes, remember card-catalogs? they had TAGS for the books!)

All in all, I (gasp!) like Microsoft's Courier, but know it will fail me (so I'm makin' my own!!)

* The smoothness working of FreeBSD
* The simplicity of CRUX
* The strength of Slackware
* The consistency of Windows XP
* The internal design of BeOS
* The device driver support of Windows XP
* The elegance of Mint
* The community support of Ubuntu
* The package manager of Arch
* The security of OpenBSD
* The user interface of Mac OS X
* The portability of NetBSD
* The SMP performance of Linux
* The toolchain of GNU

I don't find anything intolerant in what I posted. What's more, I find the tone of your post offensive. You are welcome to argue for your point of view, but dismissing what I say merely because you don't like how it comes across to you is not helpful.

XP is not consistent. A lot of OSes are more consistent. If XP seems consistent to you, I can only assume you have a limited set of experiences (and are probably only contrasting it with Linux desktops, which are mostly worse.)

If the original poster would like to reply and clarify why he thinks XP is a good role model for consistency I would be happy to read it. Perhaps I would agree, perhaps I would rip his argument to shreds. Either one would be a better contribution than your irrelevancy.

on top of that a ~~haskell/ruby~~ shell with by default reactive geometry/vector/typography rendering and that's about it. ( with automatic fallback into vga/ascii classic shell ) no hard coded graphic computing, ergonomic (fitz law, analogic changes) oriented renderer that update everything in a "coherent" manner.

with something ala plan9, aka namespace/trees representation of about anything, and nixOs .. emphasis on versionning/transactionning features of FS.

factorized/typed/generic operations as much as possible.
no "programs", just functions that are easily composable, a so-called program would just be a preconfigured function graph ~math equation etc etc

This post will be long and somewhat critical/negative. This is by necessity in both cases and it should be noted that no malice is intended.

I have given some thought to a lot of the same issues as mentioned in the article with radically different conclusions (mostly). I wont go much in to what I think but instead try and focus on what makes the article's solution good, bad, or in need of some more thought (a lot of this).

Everyone has his own idea about what makes a 'perfect' OS--or should we just say a better OS? One reason we don't have one like the article describes is that everyone has a *DIFFERENT* idea of what's better.

To me, most of the things he talks about would be VERY BAD! Giant leaps sideways and some backwards. I do *not* want my computer to 'adapt to context'. Context is irrelevant. I will decide what I am doing and TELL my computer that. It should not assume!

Example: Suppose I do go to a directory of audio files. Do I necessarily want itunes-type functionality? Maybe I want a mass tag editor. Maybe I want to zip them up. Maybe I want to do a lot of things. The computer probably *cannot guess what I want* and should not try!

What he's really asking for here is de-monolithicizing (if I may coin a terrible word) which is what BeOS does that's so good. The application should treat things that can be files as files, because that makes application interop much easier (and more logical!). Contrast to Outlook PST or even Mozilla style mail handling and BeMail is obviously superior. But, making Explorer become a mail app when viewing a mail directory... no. No! I don't want to mark my directories as "for mail" or "for pictures." This is tedious, like nepomuk tagging is tedious, and tedious things just get ignored. I don't want the system to 'guess' the way e.g. Windows Explorer now guesses what view mode to use by default based on some of the files in the directory. I don't want browsing to my mail folder to auto-load a GUI I don't necessarily want, wasting my time and computing resources.

The article's passing praise for spatial file management is suspicious and an indication of one major way in which I will always disagree with the author.

2.1 Managing Applications

Oh, horror. I agree that "no branding" is good and generic names are better... when you only have one application of any type and when the difference between types is clear-cut. In utopia there's no conflict, but we do not live in utopia.

Text Editor - vi or emacs or notepad? Wait, what about Wordpad? Or is that Word Processor? But what about Word? No, what about ooo-writer?

Okay, so let's say we only have one good one installed at a time. Which one? What happens when I invent a better way of doing e.g. a music app, because I am a genius like that. Suppose I write it in C and the current one is written in Java. I can't just patch the existing one to be like mine (maybe I do not know Java). How do I use mine instead? How do I have them both installed while testing/troubleshooting? What happens if a user wants to use mine today, but their old one tomorrow?

Example: I download the adobe ebook reader and it appears as "E-Books." But, Adobe doesn't support the format used by my favorite e-zine provider! So, I download their E-Book reader and...? Now what?

Games internally store save files? But what about multi-user systems? Are we back to the old "only 4 save slots, sorry" syndrome? What about copying games to a friends' system? What about the fact that game save files are often HUGE?

3. A Better File System Hierarchy

Restricting users to only user data is more or less done today. In Windows you just never leaver %userprofile%, in *nix you never leave $HOME. KDE and GNOME are pretty good about showing you just your home. Now, granted, you could do better at hiding the rest of the real system... but it doesn't require much work on existing systems.

All that said I think it's a bad idea. If you make things discoverable people who want to learn will learn. Just make them hidden-in-plain-sight such that users who don't want to learn will know not to get themselves in trouble. If you are too good at hiding complexity the next generation of developers never emerges...

If you really want to make things simple for the user why don't you get rid of the f--king desktop? Why would you want *devices* on your *desk*? The desktop metaphor is old and very, very broken. Trying to make software work more like the metaphor is as useless as trying to keep extending the metaphor further. This is a real area where a little well placed innovation would be worthwhile. Hint: I have never used a file folder in real life, I don't keep things in desk drawers, I don't have a desk that does anything other than hold a keyboard and monitor... and I probably represent the leading edge here.

The reality appears to be that BeFS is the closest thing we can currently get to a Database Filesystem. Remember Microsoft failing to get WinFS working? That's because this is really, really hard. So, assume you can't get a better technical answer than BeFS and build your better FS layout on its capabilities.

4. A Better File System and File Types

BeOS, as I recall, already stored the mime type of each file as an attribute in the FS. This is what you want, just have a mime-like attribute that stores a less specific mime type (e.g. text, not text/plain) and you're mostly there. Decoding and decomposing other data from files as they are saved would be helpful, I suppose. Would the import process actually te-tag MP3s? It's an interesting idea. You could not guarantee an ability to understand every kind of file that exists, nor are there ways to actually remove some kinds of metadata from some kinds of files. Example: PNGs could save a lot of header information in the FS, but it would not really be a PNG at that point.

The idea of auto-decomposing and recompiling metadata as the file moves in and out of the system is interesting. So far it's the only thing I've heard that would be useful, however impractical. On we go.

5. RISC OS’ Menus

The problem with context menus are well known, I will mention a few:
- not very discoverable
- quickly grow huge (think Windows Explorer's after you've installed a few apps. If you think this would not happen... well, think what you like)
- slows down interaction
- usually hard to access without a mouse
- did I mention really slow?

That said, maybe RISC OS had some answer for this that would survive leaving a niche OS without a lot of chaos. I never used it, so let me know.

6. Viewing / Editing Files

Again, some issues exist.
- I have GIMP and PhotoShop installed. What verbs will be used to differentiate them?
- What if you have a photo-retouching app and a painter app. Both could open images. Which one is Edit depends on who you are, so which is Edit? (And what is the other called?) You could say "Retouch" and "Paint" but sooner or later this question must be answered for the generic case.

7. Window Management

The way to avoid minimize/maximize, etc, is to use a modal interface and multiple desktops/modeviews. I know people will cry "heresy!" but this is the answer I have. No matter what you do you will need to accommodate:
- interaction between multiple app windows on the same screen
- one app consuming the entire screen
- switching between multiple full screen apps
- interaction between multiple app windows on different screens/modeviews.

Case: I want to see a tail -f style log window and a monitoring app for various I/O and my text editor for my code and my IRC client all at once.

Case: Then I want to play Quake 4 and pwn some friends.

Case: I am playing Travian (travian.us) and want to queue up 4 different attacks, requiring 4 different web browser windows with specific sets of tabs. This is a personal one, for me multiple desktops is good enough here.

I will say only this... have you tried the IRC client 'sic'? In terms of using files for things, it is quite fine... usability suffers somewhat. No, this is not on topic, but it is cool (-;

Exciting Finish:

It's nice that you're thinking, but I would never want to use this OS. Some of the ideas are interesting, most of them are just horrifying. A lot represents a naive understanding of the problems being solved.

I am really a nuts-and-bolts guy. I am more interested in how would this be implemented than a birds eye view/mockup of the interaction and concepts.

The important thing to do is understand why we're here and take into account all of the people who are not like you when designing something new. One size doesn't fit all, but doesn't everyone (more or less) use Windows?

It's easy to design an OS I would love, it's hard to design an OS everyone could live with.

I am more interested in how would this be implemented than a birds eye view/mockup of the interaction and concepts.

I am interested in the birds eye view, because I’m a designer and would lack the skills to get into the very specifics. I never set out to produce something complete and bullet-proof—these are just a collection of ideas I wanted to get off of my chest Should someone want to implement this, it would go through several hundred design revisions until all the kinks were worked out.

No, I would _never_ have the computer guess, that’s annoying. Windows XP does it, and it’s annoying. You would set folder types as and when required.

Text Editor - vi or emacs or notepad? Wait, what about Wordpad? Or is that Word Processor? But what about Word? No, what about ooo-writer?

Again, just purely ideas and I never designed it to be a solution to 3rd parties disagreeing with each other. If I could make an OS that regular people could accomplish everything they ever needed, easily, then it would still be a success—even if you couldn’t install Word on it.

Vi/emacs in particular would be system utilities—under the hood stuff like the command line, an area I haven’t described yet.

If you really want to make things simple for the user why don't you get rid of the f--king desktop? Why would you want *devices* on your *desk*? The desktop metaphor is old and very, very broken.

I never for a moment thought about my design as a 'desktop metaphor'. I just personally like my devices on the desktop picture, like we have on OS X, Amiga OS and even as I was doing so in the 1980s with GeOS. It’s one less screen to go through to get to something, unlike Windows—I hate the clunkiness of “My Computer”.

Games internally store save files? But what about multi-user systems?

An oversight, I will think about a better way of doing that. (Remember, the computer is personal).

You could not guarantee an ability to understand every kind of file that exists

File filters would be centralised like Amiga OS, so they could at least be easily plugged in and all apps would gain the ability to understand new file types.

- I have GIMP and PhotoShop installed. What verbs will be used to differentiate them?
- What if you have a photo-retouching app and a painter app. Both could open images. Which one is Edit depends on who you are, so which is Edit? (And what is the other called?) You could say "Retouch" and "Paint" but sooner or later this question must be answered for the generic case.

1. this is contrived because these things would have to be ported, and that would be unlikely, the built in editor would be as good as GIMP to begin with, and those needing something even better could swap out the built-in editor with a new binary (keeping the same verb), or use a new verb of their choosing ('Photoshop' ). Maybe “Edit (Pro)”, or have the simple editor as “Modify” and the complex editor as “Edit“.

The way to avoid minimize/maximize, etc, is to use a modal interface and multiple desktops/modeviews.

Haven’t done much about this, but one idea I had was perhaps a workspace manager could minimise / maximise entire sets of windows into an icon on the desktop. Instead of virtual desktops, you would have groups of windows that could all be hidden or shown together when you wanted, and this information stored as a file that you could name and move around. Thus you can setup a screen full of windows for a particular task (like debugging) and save this session to a file that you can open at any time.

---

Thanks for comments. Do note though, that KrocOS is just a pipe-dream and no serious attempt to solve anything, as it would never come to exist anyway. It’s just how I would design a computer ecosystem if I was like Steve Jobs, being tasked with unswervingly driving an OS how I see fit.

"Text Editor - vi or emacs or notepad? Wait, what about Wordpad? Or is that Word Processor? But what about Word? No, what about ooo-writer?

Again, just purely ideas and I never designed it to be a solution to 3rd parties disagreeing with each other. If I could make an OS that regular people could accomplish everything they ever needed, easily, then it would still be a success—even if you couldn’t install Word on it. "

There are ways to solve this problem. It could be as simple as a simple priority list: Text Editor would not be a single app, but any app that implements Text Editor. It might be possible to create an easy UI that allows the user to know that there are multiple options and toggle between them without requiring specific names. Or, perhaps a creator code type system could be used to select a preferred one if many are available.

I never for a moment thought about my design as a 'desktop metaphor'. I just personally like my devices on the desktop picture, like we have on OS X, Amiga OS and even as I was doing so in the 1980s with GeOS. It’s one less screen to go through to get to something, unlike Windows—I hate the clunkiness of “My Computer”.

Several of the things you describe, most notably any talk about folders, suggests a desktop metaphor. Sorry if this is not what you intended.

I don't have a problem with icons on my workspace indicating devices, although I don't prefer it, but don't call it a desktop (-:

"You could not guarantee an ability to understand every kind of file that exists

File filters would be centralised like Amiga OS, so they could at least be easily plugged in and all apps would gain the ability to understand new file types. "

Doesn't BeOS also do this? I do like it, it's the correct answer as far as I'm concerned, but in the real world you have to have an answer for what to do with unknown file types (or file types where splitting information out of the file is not feasible).

Ideally all files would be in some kind of nice format (I rather liked IFF and its friends) but in the real world legacy formats must be accommodated.

1. this is contrived because these things would have to be ported, and that would be unlikely, the built in editor would be as good as GIMP to begin with, and those needing something even better could swap out the built-in editor with a new binary (keeping the same verb), or use a new verb of their choosing ('Photoshop' ). Maybe “Edit (Pro)”, or have the simple editor as “Modify” and the complex editor as “Edit“.

The situation is contrived for this specific case, but in general an answer is needed. I am not against removing specific names but there are some problems with doing so. Another example: Grandma doesn't need something as complex as the GIMP or an editor of similar power, she just needs to remove red eye. Is it still a good idea to make the default editor so powerful? This is a less contrived reason why you might need two programs that can do the same thing (retouch photos).

"The way to avoid minimize/maximize, etc, is to use a modal interface and multiple desktops/modeviews.

Haven’t done much about this, but one idea I had was perhaps a workspace manager could minimise / maximise entire sets of windows into an icon on the desktop. Instead of virtual desktops, you would have groups of windows that could all be hidden or shown together when you wanted, and this information stored as a file that you could name and move around. Thus you can setup a screen full of windows for a particular task (like debugging) and save this session to a file that you can open at any time. "

I like it. It would be especially useful if I could store iconified work-sets like this on my dock, which I like to keep as an ever-present 64px sidebar on the right hand of my screen. The only thing at that point would be to make some good keybindings for rapidly toggling between them.

It would solve my need for 32 virtual desktops fairly well, without the clutter of always having 32 desktops.

You could even throw in session/state management features. When iconified the entire work-set could be unloaded and saved to disk, then copied to another computer and restored. Maybe.

Also, I would expand on this, and add that if window and program session state were transient enough that we could freely move it around (like something from Plan9), then I would like the ability that I could drag a file into someone else’s computer across the network, but instead of seeing just a folder hierarchy of that computer, I would see the actual computer’s screen with its session. In fact, I could just freely use any computer’s session on the network (if I had permissions to do so), like a super virtual desktop.

This would reduce the disconnect regular users feel with the difference between accessing data when in front of a computer, and accessing the same data from another computer. It’s not like-for-like enough IMO.

I really have to congratulate you on this post. I find it very informative and well thought out. Although I don't agree in all points with you I think we both have a very similar way of interacting with computers. Just a couple of things which I like to add which my ideal OS would have.

CLI:

Every program would be easily controllable from the commandline. I find myself doing 70-80% of my work using terminals. I don't understand why people want to use filemanagers, in 99% of the cases the work is done much faster using bash. This is also why I disagree with the whole KrocOS approach of contexts. If I go to a folder I know how I want to manipulate the files. And that could be very different from one time to the other. For example if I write an article in latex, sometimes I want to compile the file to ps sometimes to pdf, sometimes I just want to edit it or just grep a for a word. I don't want to set folder properties which decide how I interact with the file.

WindowManagement:

I agree with your premise of getting rid of maximized/minimized windows. I think virtualdesktops are far superior (and I can't believe how long it took OSX to get them). Also I want grouping of windows, e.g. all gimp windows are part of a group so I can set properties on the whole group, i.e. to have all the windows always open on the same desktop.

I tend to agree with regards to the command line, which is what I use for my file management (and a lot of other things). Originally I did this because all GUI file managers for Linux sucked. Since then I have found three that do not suck, but it's far too late to go back now.

I sometimes think I escape to the simple elegance of the command line because all GUI interactions suck. Other times I am not so sure.

The idea that the computer adapt to what you're doing is a tempting fallacy, IMO. Until the computer can literally read your mind, via a neural implant, it can only guess or not guess. Guessing is always wrong (this is not true, but it is true enough of the time that it may as well be true all the time).

Kroc had some interesting things to say about window management elsewhere in this thread, which may interest you.

I find that many non-maxed windows per virtual desktop is a rare, but not unheard of. Since I began using 32 desktops and one window per desktop (more or less, somehow I seem to find an xterm on each desktop too) I find that in all but a few cases application use is modal. But you cannot require this, because sometimes it isn't and when it isn't you absolutely must have non-modal.

I have very, very rarely wanted drag and drop. It sounds like a good interactive idea (and extends the useless desktop metaphor) but outside of painting programs I don't think I ever use it. Without drag and drop there's limited need for same-time viewing for interaction. Not to say you don't want to view different sources of information side by side, which you do, but the fact that apps do not actually share data due to user manipulation means a lot when it comes to what your window management design can be like.

Some experimentation with window management optimizing for the case where windows don't need to interact and only one app is in use at a time would probably bring forth some useful innovations.

Anyway, the perfect OS would essentially be OSX, but legally run on any hardware, and preferably open source. The kernel, and bottom end would be based on probably Solaris, or possibly BSD.

At the very least, I really really wish Linux would pick up on some of the things OSX does well, like application folders (for those who do not know, applications are bundled into a special folder, ending in .app, everything goes here, the program, resources, configuration, libraries, everything. Then all a user has to do to 'install' it is just copy it to whatever folder they like, and to 'uninstall' it, just delete it. thats it. No libraries spayed all over the place, no sym links, no menu entries, everything is contained in the .app folder).

Also, I really wish there was a bigger push behind GNU Step, it has real promise, but needs a LOT OF WORK.

1) The hardware support of Windows - both out of the box and third parties.
2) The software support of Windows by way of a large ecosystem of third party developers.
3) A FreeBSD core + Better graphics layer.
4) IRIX Indigo Magic Desktop ( http://upload.wikimedia.org/wikipedia/en/5/59/Imd.gif ) but updated.

If a company provided that, I'd be a very happy lad; a combination of power, ease of use and flexibility all rolled into one.

In the previous comments I saw some really good ideas. I encourage their respective authors to submit them as a feature requests to their favorite OSes
What I would like to have :
Tons of compatible software, installed via one click, no deps - something like PCBSD's .pbi packets (AFAIR, they don't have deps). Total and easy control from a users's perspective to the OS. Reliability and stability, supreme performance for both Desktop and system level processes. Easy upgrades, frequent updates. EVERYTHING explained in a human readable format, i.e. : "This is an update of software, version X.X. It does this, so you might want to install it. It downloads from the Net, and it's large, so please consider this, the package is about 200MB." Just an example. Then, a good backup and restore solution. Every applications has a good UI, with a lot of options - some advanced are hidden, the most often used are bring up to the front. The applications are AI - they learn the habits of the user. Nothing is being done silently, unless the user has requested it. Log files for everything, with meaningful messages, timestamps, gzipped. Portability over different hardware, no need to stuck with some fancy driver installation. Open source.
Large portion of the OS is social oriented, a good, one app, that takes care of your social activities. No need to go into konsole to fix your network card options, as instead, a nice, easy to understand UI. Compatibility layer for Windows apps. On the other hand, a comprehensive documentation for devs and geeks that love to tweak the OS. A desktop look and feel similar to Mac, everything is user friendly, and it responds really fast. Something that my mom would love to play with. Localization, support for different languages. A centralized place to control the OS (via just a few clicks).
Those are the things I suffer from today, though being a Linux / BSD user for more than 10 years. While I have already fixed some of those by myself, the rest of the users are afraid to take a shot with Linux.

1. Full persistence. Even if I cut the power and yank the batteries out, I should start in a consistent state that is at most a few seconds old when I resupply power. This also means that there is no need for a specific hibernate function -- you just cut power.

2. Hot updates. There should be no need to restart applications (let alone the OS) when you upgrade applications or OS modules.

3. Driverless devices. More specifically, let devices store their own drivers which are transferred to the OS when they are plugged in. The drivers should be written in a high-level language so they are independent of the platform CPU. Alternatively, let devices communicate with the OS through a standardized protocol. Adding CPUS to devices cost next to nothing these days, so you might as well move a lot of the "intelligence" to the devices.

4. Full versioning file system. You can go back and see any previous version of any file. You can offload older versions to the net, so you don't fill your media (this will make access to older version slow, but since it won't happen often, that's O.K.). You can explicitly ask to permanently delete some data (for security reasons etc.) but that can only happen if you enter a "management" mode, which general application can not use.

5. Location-free file system. You should be able to access data in the same way regardless of whether it is stored locally, in "the cloud", or on your data home server or the office data server.

6. Transparent parallelism. Tasks should automatically distribute over the available processors. Not just assign applications to processors, but split tasks over multiple processors. This requires a break away from the current programming models, so applications have to be written so they can be parallelised, using a language that makes this easy.

The major thing for an OS and a Software for me as a user is = it doesn´t have to be annoying.

There is no need for major updates, if a product is done it should run like that for long term. And any changes should be the choice of the user. Just like an add-on that you can install if you like or not.

For example, Mandrake 8 -> 9
or W2k -> XP

Both did not chance much under the hood, but they chanced the look & feel of the user interface and the admin interface dramatically.

From my point of view, it would be better if the new version would be an add-on and one should be able to install it or not.

Or it should be able to change things under the hood, but one should be able to choose to keep the old user interface and admin interface unchanged.

The same goes with Adobe Acrobat 5.0 -> actual Version
or Photo Shop 7.0 -> actual Version
or Winamp 2.91 -> actual Version

At the moment we have a Dictatorship of multiple companies.

That is better than one Dictatorship, like a country where only W2k would be allowed as an Operating systems for all Desktops and Servers and mobile devices. Which from my point of view would be VERY GOOD. Problems and annoyances and wasted time and wasted capacities would shrink. Imagine 1 OS for all.

But this is not doable, because there are millions of individuals on both sides, the programmers and the users.

First, I would like to salute your idea as the article tries to be constructive not destructive.

If I'll have 1 billion euros and I I'll agree to spend 100 milions to design a new OS, these are the thing I will do:

-make a team of professional OS programmers; not hobby os programmers, not other kind of programmers

-make a group to study the latest discoveries and improvements and research studies in the Operating Systems field (things like L4 microkernel family, research file systems, researc oses etc); keeping in touch with researchers and teachers from universities

-employ a research firm to really see what users want and to see how they want an os to behave

-employ an research firm to see what will developers want; ; what kind of apis amd ides they will prefere to use when they will write software for the new platform

-make a group to study latest research in gui, desktop gui design and usability

-let the programmers, designers and researchers make some brainstorming: it will come clear the os arhitecture, the type of kernel, the type of file system, the type of gui, the type of apis, etc

-everything will have to be written from scratch, heavily optimized for speed, stable and responsive and also bloat free; the os will have to be as usable as possible

-keep all things as simple as possible; don't write software monsters that "do it all". instead write a single software that does one job, does it properly and is designed with interoperability in mind.

-write the actual os according to specifications, design rules and design idees

-employ some hundreds programmers; sign NDAs with major hardware providers (AMD, Nvidia, Intel, etc) and write drivers for the new OS - don't expect them to do that

-employ some thousands programmers, sign NDAs with major software houses and port at least: the 20 most used bussiness software, the 20 most used home software , the 10 most popular games and the 10 most awaited games.

-do some proper alpha and beta testing meantime

What do you all think? Will 100 million euro suffice?

Also, please excuse my grammar mistakes, as I'm not very fluent in English.

-lack of apps (as in lack of commercial quality apps)
-bloat
-lack of stability
-unresponsiveness
-improperly designed apis
-cloud computing
-virtual machines
-non native compiled code
-lack of standards
-lack of interoperability
-1000 libs and 1000 pieces of software that does more or less the same job

I can continue for ever, but I'm only allowed 8000 characters and I'm stopping here as I pointed the most problems that I think that hider and hold back operating systems.

A new OS designed from the ground up by me would probably look like this:

* All Data is on the Web: The harddrive would merely be a cache to allow fast access times or make the OS continue working when the connection to the web is temporarily broken. The final store for all data will be on the web, so no explicit synchronisation between computers and devices is necessary they just download everything (think IMAP but for everything). You might be able to use free services (google) or pay some money for hosting provides that guarantee your privacy. In each case the providers will create backups and ensure your data integrity.

* Programs/Code is on the Web: Like for the data there are no installation routines or anything. Programs/Code is on the web - not necessarily in the limited and complicated forms that is http, javascript, ajax today - more like a universal bytecode (think javas security/vm features but better GUI apis providing ways to integrate into the system and not limiting it to the browser window). The benefits are obvious: No installation needed, external service providers will take care about updates and are responsible that everything works. Again I might pay some providers so I get the service I want and not advertisements and privacy problems with free services.

* The interface is document, task and event centric. The operating system is not about starting applications. It's rather about opening and editing and organizing documents (my e-mails, word documents, mp3 files, videos, ...). Performing certain tasks (shopping, filling government forms, making a phone call, sending emails) and getting notified of events (incoming calls, news site updates, upcoming birthdays and events in my calendar, ...) Of course there are applications in the background - but the interface won't force me to think in application terms.

* Of course I don't want to think/fiddle with my hardware. There has to be driver/universal standards for everything and the computer should just work. Additional everything should have very robust error handling. See next part.

* Robust and lots of fail safety mechanisms. The software should be as robust and correct as possible, but at the same time we have to be aware that there will always be bugs or simple hardware failures, or other failures (the hamster is eating the power cable).
The solution here is having a robust and easy failsafe mechanism: Applications do regularily and automatically save their state to the harddisk (the ram is just a cache for the state on disk) and the harddisk is regularily saved to the web (the harddisk is just a cache for the data on the web). If something fails the system must be able to reset to the last saved state on disk/the web and continue seamlessly from there. So that usually just a few seconds of work are lost.
If certain applications, drivers etc. are failing they are just restarted and the state restored from disk/the web. There have to be mechanisms that ensure data integrity so that you can really always go back to the last saved state.
Even if my computer completely fails I just want to switch to another one and continue working from there having a nearly seamless switch as the data/state gets restored from the web.

* Obviously the system would need to have sophisticated security concepts. We need good authentication mechanisms, I want fine-grained but easy to use access right management so I can share data with others. And all code executed only has just the right amount of access rights so it can perform its task but not do additional damage or read private data that is not needed for the task.

* It has few sensible options and configuration possibilities. In general I want the programs and designers of the applications to think for me and make sensible choices. I don't want them offloading decisions to me as a user about stuff I don't really care about. In doubt better use a default and hide one more configuration option. There should be many people crying out loud before options are added (on the other side they should react to many people crying out loud...)

1. clean screen interface; only the object being edited is visible all the time. Commands/options accessible only via context menu.
2. full screen interface for each edited object; other screens accessible by context action.
3. realistic rendering of edited objects; objects look like real objects as much as possible.
4. task-driven menu interface for initial user screen.
5. no double or triple clicks that confuse the user.

programming

1. system-wide garbage collection.
2. system-wide automatic persistence.
3. object-oriented language with low-level features that don't break the OO abstraction or security.
4. the Actor model being used for parallelism/concurrency.
5. abstraction on networked resources.
6. the same programming language used either for system scripting or application programming.

The perfect OS to me would have the simplicity of Macs (everything just works out of the box), the customization of Linux (basically, make it dead simple to use, and hide the advanced options just far enough out of reach so the average users don't hurt themselves), with the kind of support like Windows has. Because, after all, a great OS without great apps is pretty much a useless OS.

I agree with the one dude who said that all apps should be portable, not installed. But I would like it better if the OS came with no apps at all, except for basic OS utils (like system-wide spell checking) and a 'click n run' type appp that let you download other apps.

An operating system should be out of your way and the trend of shiny toys and widgets has resulted in clutter and reduced quality user experiences.

Today the workflow associated around navigating folders, opening documents and finding things is terrible because in most operating systems there are slightly different ways to do things because applications can implement things differently.

There is an affinity to the relationship between the documents/resources and applications I am concerned for accomplishing a particular goal, but this is usually lost when I switch off the power. Leaving my laptop session going for days is not much better because only one arrangement of windows can be stored, but I usually work on multiple streams concurrently.

I want to never have to manage/close a window or put effort into grouping applications. The only thing that matters is a document is saved, or I don't want to change it. Applications should arrange themselves usefully, a calculator adjunct to a spreadsheet app if I am clicking between them all the time.

For a full answer, I'd need more characters than OSNews grants me (or, perhaps, to write an article). But, it'd boil down to just this: Designed for the desktop, and designed only for the desktop.

Of the big two OSs, both OSs are trying to design their systems to be a desktop OS and a server OS as well as running on phones, settop boxes, et cetera. (OSX doesn't have a game console... yet; as soon as apple can figure out a way to expand their iContent to games...) And Unix... Unix was never designed so much as iteratively expanded, so modern design techniques are juxtaposed with (and are unable to displace) design goals that almost made sense 40 years ago.

Core:
1. User interrupts rule all. Realtime through and through, but with full NUMA support, where a process can be optionally flagged as preferring bandwidth, instead.

2. UTF8 all the way through. Unicode isn't perfect, no, but UTF8 is a great compromise all around. Just start at the bottom with it.

3. Local and remote resources transparently blended, a la Plan 9.

FS:
1. Unix-like main structure, but beyond setting out devices and such, the structure has pools to be accessed. A pool being not unlike an LVM volume, in terms of relating actual storage with what you see using the system. This is where the hierarchical bit of it ends.

2. Each pool would contain unique files with certain attributes, from which security and file structure could be created (persistent views) or divined (ad-hoc queries). The system would be purely relational, and support versioning of every kind (roll back files, have multiple library/app versions, explicitly view file edits, etc.)--use it or not, your choice. If you wanted a certain version of a certain library, you ask for that, rather than hope it is a path you think it should be. Applications could add their own properties to files, easily viewed by anything else in the system, for near-infinite flexibility. The security system in the kernel would be able to handle who and what has write permissions to the attributes.

3. Fancy features like replication, being able to roll back data, snapshots, what have you, would be able to be turned on and used with such an on-disk FS, or it could remain unused for any reasons you may have (save space, gain speed, etc.). FSes preferred would be 2nd or 3rd gen transaction-based non-journaled FSes, learning from pioneering ones like ZFS.

All this would allow transparent use of user, local system, and distributed system resources without propagating symlinks and whatnot. Persistent views would allow arrangements for backwards-compatibility with apps made for other systems, and to handle cross-platform apps (so, it could make an entire Red Hat file tree, FI, have a WINE-like app, and then go).

Also, you could have your favorite file manager or media browser or whatever else, whose UI could give you radically different views, and allow for radically different workflows, without screwing with the underlying system, without creating its own FS-on-top-of-an-FS, and in a way that other applications could be extended to use with minimal or no added coding. If we start to see good SMP on mobile devices (or generic stream processors in mobiles), this sort of thing could be done efficiently and powerfully with the mobile hardware of 5 years from now, as so much of it is naturally parallel, the raw data would tend to small, and the future of the workstation-like desktop is less interesting than mobile stuff or server stuff .

Data/app management:
1. Applications would have well-defined inputs and outputs, with near direct linking by using the hierarchical side of the FS. Monolithic applications, even for GUI user things, would be eschewed, in favor of using these features to tie multiple apps together. Libraries, instead of proper applications, would likewise be eschewed. Monolithic apps could be literally be front ends that controlled pipe and socket type file interfaces.

2. Files would automatically have persistence, within the limits of the file system implementation. Files would support stream, OO, and relational interfaces, so that applications would be encouraged to work directly on files, rather than using large in-memory buffers, at little to no performance penalty (or to map to those interfaces for incremental persistence of custom data structures). Applications with ownership of a file would get significant control over exact data structures used, to have better control over memory use, speed, etc..

3. The OS would have services to serialize states of these file objects to images for the disk (something more efficient, and friendly to non-hierarchical views than XML, like a compressed UTF8 Lua). Using the OO or relational interfaces, the application could declare the beginning and end of a write, for a proper transaction (otherwise, every write is one, like w/ byte-stream style files, which would remain supported directly).

4. Free RAM and disk resources would determine the aggressiveness of garbage collection (down to an embedded option for immediate freeing, rather than incremental GC). Any app that used OS-specific interfaces for managing its data would automatically get a system-wide GC, so only need to worry about direct memory management of its internal temporary structures (getting rid of such things will just get devs hating your platform, so...).

UI/development:
1. The default terminal would connect to a JIT VM, that then connected to an OS abstraction layer. You'd have a real functional programming language right there, geared towards OO. It would have included direct robust support for working with multidimensional data structures, so you wouldn't have to go through weird machinations to do basic things with objects, or roll-your-own mappings. Native machine compilation of shell scripts would be an option.

2. Included GUI would include applications to do real-time diagramming and tracing of more intricate data structures and events, because that's going to be a n00b hurdle like nobody's business, and be handy for new users of a specific system instance (your workstation or phone, FI), that already know how to use the system in general.

3. The primary GUI (make your own, if you want) would have a zooming interface, made to be menu-driven. Pack a lot on there for a keyboard and mouse, make it 10' for your TV (or tablet), have deterministic scrolling or categorical rearranging for small mobiles (FI, a separator in the WIMP-like UI makes for a submenu in the mobile), etc.. It could scale from big icons and buttons to curses. No toolbars, or anything like that (so, more like a good mobile UI that scales up nicely, than a common desktop UI that can cram itself down). Applications could provide specific presentation rules, should they need to take over sets of, or the whole, screen space. Details would depend on UI research applied to actual application workflows. The less you know there is even a WM there, the better it is working (I am intentionally leaving out managing multiple windows, as that should be a bit different, depending on hardware platform).

4. Programming libraries made for small size, and efficiency, over speed.

Robotics:
A scheduled job would be included, to make a caffe breve every morning for me. If I'm gonna dream...

So, ultimately: good horizontal scaling (including generalized heterogeneous computing), user responsiveness over throughput, and the best data and IO models yet devised, so that the rest of the system can be done the best way possible, with thorough horizontal software integration (FI, what I've laid out would make hot updates and live backups trivial, and a cloud OS UI possible, but not trivial).

Design an OS around users who know how to use computers, and throw out the stuff designed to make first-time computer users more comfortable. They aren't comfortable with a computer no matter what gets done to the UI, and it makes life harder in the long term, not just for new users but for power users.

Don't pop up a bunch of notifications when I plug in a USB thumbdrive. You don't need to tell me I just plugged in a thumb drive. How could I forget? I have a memory that lasts longer than 6 seconds, after all.

And, for Pete's sake, stop trying to guess what I'm doing, and when I decide to do something, stop second-guessing me. I KNOW WHAT THE #%$& I'M DOING!

Now, first, this has been one of the most entertaining, thought-provoking, and Wikipedia-link-following-for-hours threads in a good while. Since I've said my pipe dream, let me criticize our star, Kroc.

Branding: I somewhat agree. I think distinctive software should be, well, distinctive, but not to the point of its own foundation with a special license and everything else. The user gets, like in politics, to choose the least worst. I would go with noun/verb combos giving you program choices, but not that being everything. The thing is, how many verbs can you really have? Edit: nano, leafpad, vi, emacs, scite (an OS w/o scite is something I don't want ), joe, ...

App/OS separation: absolutely. While I ran into the char limit, I would go so far as to do things like have a very low level regex system, and most every generally powerful thing in the C++ std, boost, or standard Java or Haskell bits, that can stand alone, as shared OS functionality. Compile an app that uses it, and it just asks the OS for it. Otherwise, you can use it many different ways in the OS. There are many features should be basic OS things, and simple system programs, that get pushed into libraries and language extensions, adding obfuscation and complication. I had not thought of it in terms of branding, before, but it makes a lot of sense.

Context: yes and no. A file manager which can morph into a music manager would be neat, but maybe, just maybe, I want to see files. That is one of a billion reasons for a metadata-centric FS. You can have your cake and eat it, too, with all that context, and I can see damn files, and start my damn music player to play the way I damn want to! The whole time, neither of us have to use a radically different system to do it, and could even have that separate work flow using the same music player and file manager--just change a few check boxes in the options. To work well, though, for both, context metadata needs to be supported from the ground up.

Also, being a tinkerer kind of person, I like exposed plumbing. But, the user should not have that plumbing shoved in their face. It should be neatly against the walls and ceilings, should they want to inspect it.

App folders: *shrug* As long as I can get my app there and working, I don't care. The one thing I don't want is for a Debian-like hiding of the build system, so I can never track down enough packages in the right places, if the package hasn't had its make file tweaked for Debian. Give me Slackware or Arch's slightly bigger packages, so things actually build, any day.

FS view: hard drives matter, sometimes, and should be exposed, but not like in Windows. Add an extra button to show additional storage resources, of make a FM option. The plumbing thing, and all. make some of the innards very easily discoverable and usable, just slightly out of the way.

FS in general: I may have just been getting out of elementary school at the time, but I remember BeOS. With my current knowledge, I think a relational file system, giving defined types of attributes to a set of a bytes, is THE way to do it. You can then organize it flat, in a normal tree, in different trees, even in 3+ dimensional networks (fast indexing becomes iffy, then, of course), if you care to. UI complexity would be the major limitation (that's when you bring up a console...). Custom apps would especially be good with this, as tying data from different things together would be a snap (your calendar example, FI).

Menus: looks good to me.

File handlers: yes.

Window manager: less is better, and it needs to be adjustable by workflow. Real research is the key. Tiling WMs, Expose, Compiz Expo (grid of VWs), etc., are quite cool. The real trick is finding a good enough one, or a window/menu/task system that is flexible enough to work really well in many WM paradigms.

Calendar, RSS, address book, and the file system: that's why a relational FS, surrounded by a context-app system, would rock, IMO. Data is well-defined, at the OS level (not DE-level), and apps just do stuff to it, in a OS/FS-sanitized way.

1. Imagine seven hundred apps all named video player? or do you mean that your perfect OS would only have one player, as it would be locked out for other players?
2. BeOS had it right, thus i agree with you there.
3. Hiding stuff from the user, no matter the method is NEVER OK! As you said, if you remove an app in BeOS its effing! gone, and that is the way it should be. no binary registry or nothing.
4. yeah beos did it better and all that functionality is abailable in beos from 3rd party software. (that is free non the less)
5. Meh i still find anything due to my awsome hierarcial system. Even though the mass ive downloaded, still its not cluttered with crap. Its just a question about personal "tidyness"
6. Stupid, not worth answering.
7. oh i get it now, your perfect OS is a graphical one only.. how silly of me. You get tired of the shorcuts in a while, or too dependent on them. Thus you cant work in a "non customized to your liking" one.
8. Once again: MEH ive got google for all that stuff.

For me, the perfect OS would use open development using open standards and its applications would use open formats. This OS would thus conceivably be able to run any program created for any modern OS, viz., Linux, Win, OSX, Chrome OS (yes, Linux). This would allow me to cherry pick the best apps among the OSes that would then update them in a Linux-like way.

Most my computing these days is cloud computing, and it's just getting started in user space. Thus the browser is more dominant than the OS. So things like Web Open Font Format (WOFF) are a great step in the right direction. Still, Linux is setup and designed far better than the others.

Finish etoile, port tons of apps from mac osx. Finish GNUStep and provide a full desktop environment including webkit browser. Apple have some good ideas but it can be done better. Also linux kernel supports more hardware than osx so would be better choice to build the OS on.