Most important first:

A standardized, universally-agreed upon device driver file format without any sorts of extensions for any one OS or processor, with a universally agreed-upon API of exported functions and callable functions. Then every hardware manufacturer could just write one device driver, in this one format and there would be no problem with proprietary this or that only working under one OS and then unfairly hindering everybody else. An argument against it might be that, well, then it will be slower but the solution to that is for an OS not to use these drivers as-are but to, instead, convert them to an internal format which is more productive/efficient for that particular OS and use THOSE as the real drivers. Also, device driver writers should be encouraged to only write them in this way and no other types. People could then make utilities for legacy OSes that convert a driver of this type into a native type driver which then could be used for it. There would be no more unfair OS monopolies if this were the case, plus it would simplify device interaction considerably---just make your OS accept and use device drivers of this type (or convert them accordingly) and bingo!---every new device that is out there automatically works with your OS as well:)

The second thing, not as important but still important, would be universally agreed upon filesystem which EVERY OS would have to support and where no OS used proprietary filesystems anymore. This would considerably ease OS development and cross-platform coding issues.

Both of these would have to be very GOOD and not amateurish, of course, and WITHOUT BLOAT! most importantly and they should be designed by people WITHOUT specific corporate motives in hand.--in other words they should be developed by an unbiased source, standardized, and then implemented, unbotched, in all future OSes, with special software made for the current OSes to convert (so, yeah, it would be a little slower for current OSes but not future ones).

Uniform Device Interface?

While we are at it why don't we make sure that everybody in the world makes the same amount of money per month.
We should also make sure everybody follows the same diet and exercise plan. We would force them to follow the same diet by not giving them any food that is not according to the correct diet plan, similar to demolition man.

In the end our society would healthier and happier.

There is just one thing missing, ah yes that was it, freedom. We can't push standards on people, all we can do is make a super good standard and because it is so good others will adopt it.

Money is the thing that drives all good program development. So that would mean the company with the most money would make the decisions on the standards. Microsoft already does this and everybody hates them for it. Breaking the standards is where inovations are made, look at menuetos, it isn't going with the standards and look how popular it is getting.

To me, just getting manufacturers to give out technical documentation would help out greatly.

Just to give you an idea on how tough your plan would be to implement, here is a scenario I read in the linux forums. Get 100 people together, and show them a picture of a barn. Now all you have to do is get them to unaminously agree on what color the barn should be. If you can get all 100 people to agree on the best color that the barn should be with nobody thinking it should be a different color, I think you can convince the computer user community to agree on the same standards for devices and file systems.

Just a thought,

...Gomer73

Well as you say might not be so bad (read still wouldn't be fair but would be workable) if, in fact, all hardware manufacturers handed over all of their specifications for every piece of hardware which can be used on a computer. The fact of the matter is that they don't want to do this because then they are afraid some competing hardware manufacturer will copy/clone their design and make a better product using partially their ideas and/or they don't want other hardware manufacturers to see that, in fact, that is what they have done. Hence they're never going to just release their specifications which therefore will make the top operating systems continue to top the market WITHOUT the coders of those OSes having to write a single extra device driver (the hardware manufacturers do it for them) meanwhile everyone else is stuck with OSes which cannot support such hardware and then the end user is not going to want that and hence an unfair monopolistic maket.

Actually, about the barn example, it's all about compromise. Sure you can't have all of them unanimously agreeing on a single color just like "that". Compromise! Say, green isn't good for one person but he really wants red but orange is suitable, and etc..... so you find a combination which works "okay" for each of them yet is not necessarily ideal for any one of them. It's called a committee---that is how this would work---being designed by a committee composed of members of all (or most) of the hardware manufacturers. This way then the hardware manufacturers can make a single driver for everything from then on, OS manufacturers could just use that (or deal with conversion, which is fair) and this still allows the hardware manufacturers to keep their trade secrets safe as it would be entirely automated.

Please explain to me how it is freedom if any arbitrary OS designer is not free to incorporate any device which he wants into his/her OS? Also, how is it freedom if you (as the customer/user) cannot choose which OS hardware you buy works on/for and have to choose OS based on what your hardware supports? That is not freedom. That is the opposite of freedom. What I am suggesting is freedom.

And, yes, some manufacturers give out the specs but it is not enough. In order to be workable, ALL of them would have to give out the specs to anybody and in order for it to be entirely fair, they would have to write device drivers for every OS (since they do it for the major OSes anyway--why should they get this service when others don't?).

Anyhow, Uniform Device Interface thing looks interesting---we can see if that is implemented in the future. I am a little bit disappointed to see that it is hosted by Caldera, however. I hope it doesn't become anything biased because if such a standard is biased it would be worse than no standard. If it has any sorts of extensions to it specific to certain OS(es) that also would be worse than no standard (and would be biased). We'll see.

I guess you haven't heard, life isn't fair.
It's all about money.
Why would Microsoft support your committee, you are just one person, it is Microsoft who has all the pull.
A lot of video card companies don't design their cards to be the best they can be, they design them so that they can get the high numbers in the benchmark tests. Then magazine can write articles on how well that video card did and people will buy it. It makes since for them to optimize the card for a specific OS since it is the most popular and will have the largest market and therefore make the most money.

Lets put it this way, suppose there was a universal standard out for just video cards. If a company could optimize it for Microsoft OS's so it performed twice as fast, do you think they wouldn't just so that they could follow the standard. The users would like them to do it, Microsoft would like them to do it, and the company itself would like to do it. The only person that doesn't want them to do it this committee. The committee has no power.

It is the same thing as Grub a lot of development has been put into it, but the Grub comittee has no power. I have no desire to use Grub, MenuetOS and SolOS don't use grub. The code is very simple used to boot an OS, so why would we conform our OS to the Grub comittee?

You need power to influence programmers. Microsoft has the most power, and even it doesn't have the power to do what you are saying. Not only are there other OS's popping so people aren't just supporting one API, but there is different hardware, the Mac's which are doing fairly well as well.

You can't get everybody to agree on everything all you can do is gain power and influence people with that power. Linux has gained some of this power, so companies are starting to make device drivers for them as well.

Freedom is considered freedom of opportunity, not freedom of results. It is like survival of the fitest. In the wild every animal has the right to try and survive. More than likely the strong will survive and the weak will die. What you are proposing is not freedom, but you are proposing that everybody dies the same, so that all the weak survive.

If an OS is good, companies will naturally make device drivers for it.
Just like me if I was a designer would I use my programming resources to make efficient drivers for linux? No, simply because the GUI is crap for linux where as the GUI for Windows is much better. Therefore if my programming resources are limited I would only make drivers for windows, if I had spare programmers kicking around then I would also make drivers for linux, but it would definitely be a lower priority.

The freedom you are talking about is similar to this. "I would like everybody to treat me nice even though I am a jerk." It is the same as saying my OS isn't really too functional, but I want every device out there to be able to work with it.

It is not so simple to get devices working even on a specific OS, never mind a generic standard.

And what you mentioned is the problem with comittees. Who controls the comittee? If it is a paid organization they can be bought. If it is not a paid organization they can do whatever they want and not necessarily go the way the community wants to.

...Gomer73

yadda yadda politics and conspiracies, whatever. Thing is that OSes are just too plain different to have a universal driver model and still achieve good performance. You could go for a lowest common denominator and perhaps get okay performance - but what if the LCD would be a thing like PIO compared to the DMA modes of todays IDE drives? And also consider things like mac vs. PC (both using PCI), or 32bit vs. 64bit PCs...

Oh I think you are mistaking me here. I am not saying that the drivers have to be used "as-is". Basically my idea is to have a high-level description language which will be what the drivers can be written in, with a standard for each type of driver (for example, a driver format for monitor drivers, a different driver format for keyboard drivers, another for mouse drivers, another for graphics card drivers, another for sound card drivers, etc...) and the formats should be loose enough and include things in them such that would allow for any feasible future expansion (for example, the mouse drivers should allow for an unlimited amount of buttons and scrollwheels, etc...). There would be a separate description format for each type of driver but all devices of a certain type should hold to the driver format for that type of device--make sense?

Then, when installing a device driver for the operating system, you would perhaps click on the file of the driver you want to install, then the OS can parse the driver file (figuring out which type it is/etc) and create, then, files of the native device drivers it would use, using the information in the description language as a guide, then install the actual drivers. The efficiency of this whole ordeal would depend exclusively on how good the OS coder is at creating a conversion program that converts drivers between this format, and native driver format. Then, BANG, suddenly all hardware works for all OSes;)

[quote="ShortCoder"]the formats should be loose enough and include things in them such that would allow for any feasible future expansion (for example, the mouse drivers should allow for an unlimited amount of buttons and scrollwheels, etc...).quote]

Yeah, that should be a piece of cake, to create a standard to allow for any feasible future expansion.

Why stop at drivers. I think OS's should be developed so that they allow for any possible feasible hardware expansion. Then we wouldn't need drivers at all, it would all be built into the OS.

Just out of curiosity, how much hardware programming have you actually done? The only reason why I ask is that you seem to have all the final answers but no concept of how to get there. I would recommend you write a protected mode DMA driver for hard drives. Once you have finished that, you might want to change your proposal, since it might not be as simple as you first thought.

Enough to know you usually do something like put address of specific hardware register in ax, put specific hardware address port for sending data in dx, do an out dx,ax then put address of hardware port for retreiving data in dx, and do an in ax,dx. (for getting input from the hardware...for sending output you'd use the same port you used in the out instruction for another out instruction, this time with the data sending) (or similar with al or eax instead of ax or using hardcoded port number instead of dx) The differences in programming pieces of hardware are which port(s) are used, whether these can be relocated, what the addresses of the registers are, what those registers do, if there are registers at all, --I think that about covers it.

So, it would seem, then, that what is needed is information concerning which port(s) it can use, which are for input and which for output, which registers it has, etc... along with information which isn't needed by the hardware but is needed by the OS for interfacing with that hardware (example would be how many buttons on a mouse, for example). Again, I don't have all of the final answers but at least I'm trying! Again, I can't have the entire example here of this idea implemented on any one particular type of hardware as I am just one man and, again, as I said, this would take a committee of talented professionals to design.

But, for sake of argument, it could be something like the old Windows .ini files or else even an XML file with this stuff in sections --for example



This is just an example pseudo-implementation. There are many ways in which it can/could be implemented.

I am not claiming to be the "all-knowing" source of how to do this but I am fairly confident that it could be done--that it is possible to do. As you can see from the above, I clearly have a concept of how to "get there". The question is "Do I have the power and resources to implement this universally?" and the answer is, of course, that I do not.

I am throwing ideas out there because maybe, just maybe, someone with greater resources or abilities than mine will spark an idea from some of this which can then be useful to that person. I really don't care if I receive zero benefit from this whatsoever and someone else rakes in all the profits (were there to be such profits from this)--if so, I say, GOOD for that person! In fact, I really can't be bothered to implement this on my own as it would take entirely too much of my time and since I don't have the resources available to accomplish this anyway. I am hoping that I can benefit someone in some way, even if this entire idea is bunk--if it sparks some other, related idea, which then turns out to be beneficial, what was the harm in it?

I really don't see how it makes this proposal any more or less valid whether or not I can program protected mode DMA transfers to/from hard drives. The point is that there are other people who can and maybe, just maybe, one of those people will see what I am thinking about and maybe glimpse the possibility of it all and can maybe work with other such people to accomplish this.

It is very rare I actually program at the hardware level because
1: It is already implemented in an OS API function which is device independent.
2: If I'm not coding in DOS then I would be having to write drivers for whatever OS I was coding for and I am not too familiar with the exact details of the exact device driver file formats used.
3: After all of that work and slaving, WOW...amazingly, all I have to do is change my hardware to that of a different vendor or even a different piece of similar hardware from the same vendor and, amazingly, my software will not work anymore;)

That being said, I have only done very minimal I/O programming under 16-bit real mode DOS but that is why. It's not that I couldn't--it's that I don't see the need to and some challenge is not going to make me alter my priorities to satisfy the challenge either. In order to do it would require you had the hardware specs right there, which, obviously, are not given out for all pieces of hardware, which, therein lays the problem;)

Granted there are some standards in the hardware community for certain types of hardware (VESA, for example), and maybe more standards along those lines (provided they are implemented correctly in hardware) would accomplish the same or similar benefit to what I am proposing, so if you can get that working/rolling, great!

I am trying to think of (or at least start the ball rolling) on solutions to what I will call the "hardware problem". Rather than criticize a mind trying to brainstorm possible solutions without providing any suitable alternatives of your own, why not open your mind a little bit to the possibility that there might be something to it? I mean there might not and it could all be bunk, but then again it might!

If anything, it got you thinking, right?

Of course I am not going to be able to implement this myself as I do not work for any hardware manufacturer and I think this would best be designed by the hardware manufacturers themselves in committees. Please do not expect so much out of me.

Yes, uniform drivers would be fair, and much easier to develop/encourage new OSes ! When you are alone - or about - to develop your OS, thinking of the thousands of hours to develop the most useful drivers is quite discourageing. A .INI or .XML or whatever would be so nice. Sigh.
Actually I dunno if UDI will perform this, are they still alive.

Concerning FS, there are enough good ones and widespread, no real worry.