Submitted by Greg Kroah-Hartman’s announcement for free Linux driver development included the necesssary legal framework to honor NDAs when creating GPL’d drivers. This allowance was discussed on the OpenBSD -misc mailing list. In a public exchange with Greg KH, Stephan Rickauer said: “Now these companies have a great excuse to keep specs locked up tight under NDA, while pretending to be ‘open’. The OpenBSD project has made clear more than once how this will hurt Free Software in the long run. Signing NDA’s ensures that Linux gets a working driver, sure, but the internals are indistinguishable from magic. It is a source code version of a blob.” OpenBSD founder Theo de Raadt called the free driver effort a farce, “you are trying to make sure that maintainers of code – i.e. any random joe who wants to improve the code in the future – has less access to docs later on because someone signed an NDA to write it in the first place. You are making a very big mistake.”
you. they are killing Linux this way. Linux is not Windows. Linux is about open source software. It is strange that BSDians complain about this and not Linuxians.
Linux is about open source software. It is strange that BSDians complain about this and not Linuxians.
My thoughts exactly…I wonder about the reaction to this from anti-GPL posters, who frequently paint BSD as “less radical” and more “corporate friendly.”
My thoughts exactly…I wonder about the reaction to this from anti-GPL posters, who frequently paint BSD as “less radical” and more “corporate friendly.”
It doesn’t change anything. A corporate can still take whatever code they want and use it as they want.
I wonder about the reaction to this from the GPL Linux zealots posters, who frequently paint the Linux world as a defender of the OSS…
It doesn’t change anything. A corporate can still take whatever code they want and use it as they want.
Sure, but I’m not talking about reality here, I’m talking about the fallacious propaganda spread forth by anti-GPL posters…you know, the ones that say “proprietary and BSD = good, GPL = bad.”
I wonder about the reaction to this from the GPL Linux zealots posters, who frequently paint the Linux world as a defender of the OSS
As far as I know, these people already say that closed-source drivers are bad, and they’ll probably disagree with this too. (Oh, and for them it’s “Free Software”, not OSS…)
What you probably meant was the reaction for the large majority of Linux users, who are not quite as concerned with these issues (for better or worse).
What I do note is that a BSD contributor talked about Free Software rather than OSS. It tells me that BSD contributors are actually much closer in spirit to pro-GPL advocates than they are to the anti-GPL advocates who use them in their attacks on Free Software…
Everything is a bit messed up about who is who in the Free Software world.
One one side, the FSF awarded Theo de Raadt for his defense of Free Software, while I don’t think they plan to award Linus Torvalds anytime soon.
On the other hand, it was Linus who adopted the GPL for his kernel, while the BSD guys don’t want to see any GPL’ed code “polluting” their base systems.
So BSD people (especially OpenBSD) are closer to the Free Software Foundation’s ideology, but reject its license. Linus doesn’t even like the word Free Software and prefers OSS, but uses the GPL and all the GNU tools (well, not him, but it’s necessary to use them to build an operating system around his kernel).
So in the GNU/Linux system, the “GNU” part is probably against NDA’s for drivers while the “Linux” part agrees to it.
The BSD people are against the NDAs but if drivers become completely open source under the GPL they won’t touch them either.
One thing I wonder… If Theo de Raadt is such a strong advocate of Free Software, why does he use a license that allows closed source and non-Free redistribution of his code?
Everything is so strange…
I just wanted to add a remark about
“..BSD guys don’t want to see any GPL’ed code “polluting” their base systems. ”
I hear this from many people who feel that *BSD folks feel that GPL’d code is icky and has koodies; using it with *BSD will make *BSD crash and die or become Linux ! This is not the case, it has little to nothing to do with a hatred for Linux either.
I feel that this has more to do with how the various licenses work in a layered scenario; and how the various bits of code work together. For example when you take BSD’d code base and add some GPL’d code to it; what license is the new code licensed by? Do you now have GPL’d code or can I turn that into a new BSD’d license. I am sure I dont not have this exactly right but you can see my point.
The other thing here is distinguish the difference between adding GPL’d clode to NetBSD FreeBSD and OpenBSD , base systems which has been done and is still being done ( I.E. the gnu tool chain ) , and adding parts of the Linux kernel to the various BSD kernels. The latter of the two is closer to your statement of “the BSD guys don’t want to see any GPL’ed code “polluting” their base systems “
One thing I wonder… If Theo de Raadt is such a strong advocate of Free Software, why does he use a license that allows closed source and non-Free redistribution of his code?
Well, he might be an advocate of free software, but certainly not Stallman’s version of free software…
In fact, the “freedom” part really depends on your personal vision and values. I believe the LGPL is the fairest licence, yet I’m sure many programmers here would disagree. In the case of BSD folks, perhaps derivatives can be closen, but the original code will still be around, being free. Seems to be enough for Theo & friends.
The “free software” term is a little bit confusing. In reality, the “free software” we are used to talk about be named something like [i]stalldom[i] software. It’s nothing against the guy or his projects, it’s just what it is. All licences are adding restrictions. Some are doing it for “ensuring freedom”, but it’s not completely free, nonetheless. Not to mention there is “free” as in free beer…
Theo de Raadt is not a proponent of the Free Software described by the Free Software Foundation, he does not believe in the copyleft, the sociopolitical slant, or the idea that proprietary software is bad.
That is why he uses the BSD licence, that is what makes OpenBSD what it is. The GPL’s viral effect, the way the GPL infects any code it comes in contact with, is morally objectionable to de Raadt and those who work closely with him. They are altruistic, giving away code as a way of saving the rest of the world the effort of reproducing the work they have already done.
Remember this core thing if nothing else, not everyone is trying to suck Richard Stallman off.
The GPL’s viral effect, the way the GPL infects any code it comes in contact with
The GPL doesn’t infect any code it comes in contact with. That’s just inflammatory rhetoric spewed forth by the likes of Steve Ballmer.
They are altruistic, giving away code as a way of saving the rest of the world the effort of reproducing the work they have already done.
Yes, which is the same thing the GPL guys are doing, with a tiny difference: there is a condition that you must be altruistic too if you use the code and plan on redistributing it.
Neither is nobler, or freer than the other. To argue one way or the other is to engage in yet another sterile debate over licenses, the likes of which we’ve seen too much on this site already.
Remember this core thing if nothing else, not everyone is trying to suck Richard Stallman off.
Hey, kid, if you have an axe to grind, at least try to keep it above the belt. Not everyone who uses the GPL is “trying to suck RMS off.” Remember that, of all the projects on SourceForge, there are much more that use the GPL than the BSD license…that’s a lot of people you’re dumping on at once.
Which reminds me: doesn’t the BSDs come with GCC as the default compiler?
If you don’t understand how the GPL functions, feel free to read over it, the viral effect is a feature of the licence, it’s the purpose of it the licence. Any BSD code that enters GPL code becomes GPL code, and GPL code that enters BSD code turns the code GPL, it’s quite simple, that’s how a viral infection works, it spreads into everything it has contact with.
The GPL isn’t altruistic, it’s reciprocal, I’ve given you this, now, give me what you’ve got.
I’m not saying one is nobler, I am calling it as it is. One definately is freer than the other, the BSD has less restrictions, the fewer restrictions something has, the more liberal it is.
Axe to grind? What ax? I am responding to a troll’s comment on how because Theo de Raadt doesn’t lick Richard Stallman’s testicles, he doesn’t actually support free software.
The GCC is, in fact, the compile suite used by the BSDs, what of it? The compiler isn’t infecting the drivers, it’s not infecting the userland, it’s just sitting there, not infecting anything.
If you don’t understand how the GPL functions, feel free to read over it, the viral effect is a feature of the licence, it’s the purpose of it the licence. Any BSD code that enters GPL code becomes GPL code, and GPL code that enters BSD code turns the code GPL, it’s quite simple, that’s how a viral infection works, it spreads into everything it has contact with.
“Entering” and “coming in contact with” are two different things. The second expression, which is the one you used in your previous post, is deliberately inflammatory, just as comparing it to a virus is. When GCC compiles code, it certainly “comes in contact with it”, but it doesn’t make the code GPLed. When a BSD library is used by a GPLed program, the BSD library doesn’t become GPL, even though its code comes into contact with GPL code. Redistribution of code that *contains* GPL code must be done under the GPLed license, but that goes beyond just “coming in contact” with it.
The GPL isn’t altruistic, it’s reciprocal
It’s both, actually. It has altruistic goals, and a clause to propagate the altruism.
One definately is freer than the other, the BSD has less restrictions, the fewer restrictions something has, the more liberal it is.
But one can be incorporated into code that is then made un-free, therefore allowing the decrease of the freedom of users, while increasing the freedom of developers. That’s what I mean when I say that one isn’t freer than the other, because it depend whose freedom you’re talking about. They are both free, in different way. Trying to quantify that amount of freedom is a fruitless exercise.
Axe to grind? What ax? I am responding to a troll’s comment on how because Theo de Raadt doesn’t lick Richard Stallman’s testicles, he doesn’t actually support free software.
The poster was not a troll, he was stating his opinion, and nowhere did he mention RMS, nor any part of his anatomy. Use of needless vulgarity and off-topic mention of RMS are clear signals that you have an axe to grind.
Edited 2007-02-17 05:48
But one can be incorporated into code that is then made un-free, therefore allowing the decrease of the freedom of users, while increasing the freedom of developers.
And that safe incorporation into proprietary code can lead companies, such as mine, to donate a lot of code back, as an act of good citizenship for not having to worry about gpl infection of our intellectual property.
That’s what I mean when I say that one isn’t freer than the other, because it depend whose freedom you’re talking about. They are both free, in different way. Trying to quantify that amount of freedom is a fruitless exercise.
It is difficult to quantify. But as someone who has contributed significant chunks of code into both worlds and who has had to justify the investement in doing that to corporate management, I’ll come down on the “BSD is freer” side.
It has never seemed to me that BSD license versus GPL is a matter of user versus developer freedom. Rather, it seems like a matter of which sort of developer is shackled. The users tend to benefit about the same from either license. It’s the corporate programmer who can’t use GPL-ed code in closed source, and only that programmer who loses in either case.
And that safe incorporation into proprietary code can lead companies, such as mine, to donate a lot of code back, as an act of good citizenship for not having to worry about gpl infection of our intellectual property.
Don’t get me wrong, I’m not actually taking sides in the debate, just noting that both can be considered freer depending on the philosophical context, and therefore it’s just simpler to say that they are both free, but differently.
It is difficult to quantify. But as someone who has contributed significant chunks of code into both worlds and who has had to justify the investement in doing that to corporate management, I’ll come down on the “BSD is freer” side.
Of course, because you’re considering this from the developer’s point of view, therefore your perspective on freedom is different than someone who only sees it as a user.
The users tend to benefit about the same from either license.
Only if you consider the actual licensed code, but *not* its potential derivatives. Once you factor in derivatives (and you *have* to, since that is after all what the licenses are about), then BSD does not promote the user’s freedom quite as much though it offers developer more freedom. So while derivatives of GPLed code are guaranteed to remain free for users to redistribute, derivatives of BSD code are not.
It’s an interesting argument, anyway, and is reminescent of an interesting debate about the nature of democracy: do you allow for people to elect totalitarian parties, i.e. parties that will then abolish the democratic regime… If you don’t, then it’s not real democracy, because the will of the people is restricted in some way. And if you do…well, you end up with Nazi Germany, born out of the ultra-democratic Weimar republic.
Limiting freedom in order to guarantee it does sound Orwellian, but the argument in favor of it *can* be made. Anyway, I don’t expect us to agree on this, but at least I didn’t wonder if you were confused or stupid…
Edited 2007-02-17 06:07
The users tend to benefit about the same from either license.
Only if you consider the actual licensed code, but *not* its potential derivatives. Once you factor in derivatives (and you *have* to, since that is after all what the licenses are about), then BSD does not promote the user’s freedom quite as much though it offers developer more freedom. So while derivatives of GPLed code are guaranteed to remain free for users to redistribute, derivatives of BSD code are not.
But that guarentee is only half the issue on derivities. In practice, the people who make derivatives have incentives other than the GPL for making the derivative work available and they have incentives to not use GPLed code because of the risk.
(Peter Salus’ formulation of an old saw applies: The difference between theory and practice is always larger in practice.)
But that guarentee is only half the issue on derivities. In practice, the people who make derivatives have incentives other than the GPL for making the derivative work available and they have incentives to not use GPLed code because of the risk.
Indeed, but again this is from the point of view of the derivative’s developer, not of the derivative’s user. The developer has an incentive to release the derivative under a more restrictive license (to make a profit, or at least try to recoup the costs of development), so the BSD offers the freedom to do this. From the user of a closed-source derivative, however, that means a potential loss of freedom.
Again, both points of view are justifiable, which is why arguments as to “which is more free” are essentially fruitless. I myself have no problem with the two licenses coexisting.
Indeed, but again this is from the point of view of the derivative’s developer, not of the derivative’s user.
It’s from either view point. If GPL causes commercial developers to not use the GPLed code, there is no derivitive and users lose. If BSD license allows developers to convince management to use BSD licensed code and the code is released users win. If BSD licensed code is available to the user only in binary but provides them functionality they want. They win.
The only one who can lose from BSD licensed code is the user who wishes to develop further derived code that’s not available. There is, in practice, very little such code.
If GPL causes commercial developers to not use the GPLed code, there is no derivitive and users lose.
The users do not lose freedom, since in that example there is no program for them to lose freedom over in the first place.
If BSD licensed code is available to the user only in binary but provides them functionality they want. They win.
They “win” the opportunity to use the program, but they lose the freedom to redistribute it (among other things).
You’re talking about two different things here: the availability of a particular piece of software, and what the users can do with it.
BTW, I understand your point completely, and I’m not saying that making closed source code from BSD code is bad – just that it can limit the freedom of users, while increasing the freedom of developers. Whether a developer chooses GPL or BSD for their work depends on what they value most: the freedom for other developers to produce closed-source derivatives, or the freedom of users from such closed-source derivatives. Both are justifiable from a philosophical/ethical point of view, therefore one cannot be said to be freer (or better) than the other, IMHO.
If GPL causes commercial developers to not use the GPLed code, there is no derivitive and users lose.
The users do not lose freedom, since in that example there is no program for them to lose freedom over in the first place.
The user’s loss of freedom stems from the developer’s loss. The user can’t use the modified code because the lack of freedom imposed by the GPL prevented the programmer from writing it in the first place.
Whether a developer chooses GPL or BSD for their work depends on what they value most: the freedom for other developers to produce closed-source derivatives, or the freedom of users from such closed-source derivatives. Both are justifiable from a philosophical/ethical point of view, therefore one cannot be said to be freer (or better) than the other, IMHO.
In theory this is true. In practice, as demonstrated by TiVo and Google it is not. Google has made plenty of derivitive changes to Linux that they haven’t released and yet their software is used by users all the time.
The user’s loss of freedom stems from the developer’s loss. The user can’t use the modified code because the lack of freedom imposed by the GPL prevented the programmer from writing it in the first place.
You can’t lose something you never had in the first place. There is a difference, in my mind, between the code not existing, and the code existing but being closed. From a practical point of view this is pretty much the same, but from a philosophical point of view it does matter.
Take for example those who claim that piracy is stealing, because it takes away revenue from IP producers. However, this is inaccurate because there is no reason to believe that those who download pirated IP would have bought it if piracy was not possible.
In theory this is true. In practice, as demonstrated by TiVo and Google it is not. Google has made plenty of derivitive changes to Linux that they haven’t released and yet their software is used by users all the time.
Right, in this regard (at least the Google case) licenses are irrelevant, because the software isn’t actually distributed, even though it is used.
I do believe you can dowload GPL-derived software from the TiVo site, because (unless I’m mistaken) the software is actually distributed as part of the hardware. I’m not sure about this, though.
One cannot propigate altruism, it is no longer altruism when you are forced into it. Therefore, the GPL is not altruistic the second time around, even if the initial intent is. But the licence is not altruism, as I have said, it is reciprocation.
How code is used does not effect how free it is, the restrictions imposed upon it’s usage does.
Implying that only the goals and opinions of the FSF and thus RMS matter is trolling, no matter how it is said. I could not give a shit how one feels about vulgarity, shit, goddamn, cocksucker, motherf–ker, c*nt, ass.
One cannot propigate altruism, it is no longer altruism when you are forced into it.
You are not forced into it. You agree to it when you use the license.
But the licence is not altruism, as I have said, it is reciprocation.
And I argue that it is both.
How code is used does not effect how free it is, the restrictions imposed upon it’s usage does.
Licenses are not concerned with how the code is used; they only matter when it is redistributed.
Implying that only the goals and opinions of the FSF and thus RMS matter is trolling, no matter how it is said.
I saw no such implication, though you clearly inferred this.
I could not give a shit how one feels about vulgarity, shit, goddamn, cocksucker, motherf–ker, c*nt, ass.
That only shows your lack of maturity and debating skills. I guess you don’t care about your posts being buried either. Keep it up, kid, and you might even get banned.
Edited 2007-02-17 18:04
doesn’t the BSDs come with GCC as the default compiler
Yes. OpenBSD has looked into BSD licenced compilers, but none yet have the wide platform support need to compile code on all of the platforms that OpenBSD runs on.
It’s not really a urgent issue, as the only people who would only get hit with viral aspect of the gcc licence are those who want to extend gcc itself. And in that cases there is a BSD option available (Tundra) with the side effect that it only compiles code for popular platforms (in which case it’s likely not an issue).
This whole BSD vs GPL thing is geting lame. BSD licences are choosen when a developer want to release free code for the widest possible usage (commercial and OSS), and GPL is choosen to contribute to the pool for copyleft software (ex: to presuade other devs to also contribute GPL code).
That’s what this whole issue is about. The OpenBSD devs are concerned that hardware companies will expect that NDAs will be the norm, thus hindering their efforts for quality hardware documentation (leading to quality drivers) for all, and some of the Linux devs just want a wide array of drivers (no matter how they are obtained) to further the usage of the GPL (linux) pool.
To those who say that the BSD devs could just reverse engineer the GPL drivers, take a look of the reasons why documentation is prefered here: http://www.openbsd.org/papers/opencon06-docs/index.html
It’s actually tendra, not tundra. The developers have repeated pined for the lack of liberal release of the plan9 compiler, as that is one they would be willing to extend if it were available.
The GPL doesn’t infect any code it comes in contact with. That’s just inflammatory rhetoric spewed forth by the likes of Steve Ballmer.
It’s viral.
Viral phenomena are objects or patterns able to replicate themselves or convert other objects into copies of themselves when these objects are exposed to them.
http://en.wikipedia.org/wiki/Viral_phenomenon
Any code exposed to GPL is converted to GPL, that’s the fact.
hich reminds me: doesn’t the BSDs come with GCC as the default compiler?
Yes but all modifications made on GCC are under the GPL, you have no choice.
Edited 2007-02-17 17:08
thats not quite true, all modifications you DISTRIBUTE have to be gpl.. simple, fair, and works excellently well.
in the privacy of your own harddrive though, we dont care
Any code exposed to GPL is converted to GPL, that’s the fact.
No, that’s FUD.
If you take BSD code and mix it with GPLed code, the original code still remains BSD.
As the owner of code, you can also re-license it under a second license.
Ehh? The BSD-license is a copy-left license. A weak copy-left but none-the-less a copy-left license.
The de Raadt have several times stated that proprietary software is bad, especially when it comes to drivers. He’s “sociopolitical slant” is even stronger than Stallmans slant – which says quite a bit.
The resemblance between BSD and GPL is much much larger than the difference. The pro-Microsoft anti-GPL zealots just don’t want to recognize that fact.
BSD and GPL have the same goal and almost identical approach. If just people would look at the resemblances instead of the one minor difference.
Being able to make closed software from one, and not with the other, it’s not what I call a ‘minor’ difference …
It is perfectly possible and legal to create and use proprietary software with and based on GPL’ed software.
It is a minor difference, because BSD and GPL are 99.9999999% identical in spirit as well as rights granted. The 0.0000001% difference is minor. Besides, the BSD is viral as well (it doesn’t matter much though, due to the rights granted)
If you don’t understand something, try not talking about it. The spirit as you call it, of the licences are very much different. It’s been said a millions times, but since it has not sunken in yet, the GPL is greedy and the BSD is giving.
There is nothing wrong with wanting something back for your work, but it is very different from simply doing work.
The BSD is not viral, it’s copyright carries over to derivative software, but it does not force all derivatives to be released under it’s conditions, it does not prevent further restrictions – if it did, it would not be possible to add BSD code into GPL code, because the GPL has more restrictions than the BSD.
I call bullshit on you, and I call troll, MS-apologist and anti-BSD, anti-GPL and anti-FLOSS zealot.
BSD is viral, but the effect is minimal due to the rights granted. All licenses are viral, no matter what people claim.
Both BSD and GPL are good licenses. BSD is the anarchy license (complete theoretical freedom and no protection of rights) and the GPL is the democratic license (as much personal freedom as possible (e.g. limited theoretical freedom) with only one limitation – you are not allowed to limit other persons freedom).
I would argue that there is a lot of evidence too suggest that BSD style licenses allow companies to further thier goals of flooding the world with patent laden products.
What if I said I have 3 investors for my new patented OS I am building for the embedded market. The lawyer tells me we can’t give you any money unless you come up a proof of concept in 4 months.
I get sad….but then! I get happy! You see I live in a BSD style universe.
In a BSD universe, I just pull a huge ton of the non patented parts of my OS together, and then do the hard patented stuff in 1 month.
Compare that with a GPLv3 universe. It would be impossible.
I am not sure what parts you think I am BS’ing.
As you point out, BSD is an Anarchal license. I am not so sure anarchy is what this industry needs right now.
-Hack
You cannot (in theory at least) patent the part that uses BSD-code due to prior art.
OTOH nothing prevents you from patenting GPL’ed code, you have written. You just have to understand that releasing it under the GPL equals granting a right to use your patented code.
Besides that nobody uses software patents today – except for the large software companies who are using patents as the software equivalent of the A-Bomb.
The major part of the world doesn’t even support software patents – and the major part of software innovation happens in countries without software patents. From an IT-perspective USA has become irrelevant. India, China and Europe are much more important.
Apologist? Anti-BSD? What a f–king crock of shit. Have you even read anything I’ve posted you dipshit?
Have I even once, once, mentioned Microsoft? Have I apologized for their monopoly? Their exploitation of it? Their anti-competitive practices?
I morally object to the GPL, but I have nothing against people doing whatever the hell they want with their time. I, in fact, have my own licence, the SMOL, the terms are that anyone can use my code for anything so long as they suck me off for each copy they produce making use of my code. Oddly, noone uses my code.
I am fine with free software, I am fine with open source, what I am not fine with is bullshit, and you are full of it.
I have never once been against the BSDs, because I am posting from an OpenBSD machine right now. I use BSD code, I even donate funds annually to OpenBSD.
Nice to see the zealots on the run. At least Hackus is openminded.
The BSD is a good license, and so is GPL. People claiming otherwise are either MS-apologists or GPL-zealots.
So in the GNU/Linux system, the “GNU” part is probably against NDA’s for drivers while the “Linux” part agrees to it.
What the hell makes you think that Linux developers like signing NDAs? Your statement is 100% FUD.
There’s 100% agreement in the GNU/Linux community here: NDAs are crap. But NDAs are just the “least worse” option, and it’s a nice way to get hardware companies into the open source world. It’s a start.
_Nobody_ in the open source community (certainly no linux kernel hackers) likes NDAs. It’s just that if you don’t agree to sign a NDA, you don’t even get a open source driver.
And while it’s true that a open source driver may not help you to understand 100% the hardware, it’s not exactly code ofuscation nor a “black box”, either.
NDAs are a good start to change the hardware mindset against open source. I can’t see how showing the hardware world that open source will not kill their hardware sales and may even increas it, it’s a bad thing. I just can’t understand the *BSD position.
Edited 2007-02-17 02:14
No, NDAs reinforce the idea that noone needs real access to hardware specifications. That’s the position, that’s how pretty much anyone in the OpenBSD community sees it.
It doesn’t look like there is agreement within the GNU/Linux community, since developers keep working with NDAs. The lesser evil is not the best option, there is also the good option – not signing any NDAs. The smallest evil is still an evil, no matter how much you say it’s the best choice.
It doesn’t look like there is agreement within the GNU/Linux community, since developers keep working with NDAs.
…and what makes you think that they like them? They just sign it because they think that signing them and producing open source drivers it’s BETTER than not having anything.
To start with,, signing a NDA automatically makes a developer the responsible maintainer of that driver. Forever. Instead of getting fixes from other people that has access to the open specs, it’s them who must do all the work. Its not fun, and I can bet you won’t find a single open source developer that likes it. f–k, it’s against the open source principles. *nobody* is arguing that.
(BTW, I find funny that the guys that claim that NDAs are evil are the programmers of an OS with a license that makes closed-source drivers possible)
If I walk into your house and start smoking, do you comment on it? Do you ask me to stop? Demand it? Do you stop me physically?
If you do nothing, say nothing, then you support me smoking in your house, if you join me for a butt, then obviously you support my smoking in your home.
If you do not oppose something, you accept it. If you work with it, support it even, then you accept it. If you like it does not come into play, you’ve accepted it.
Signing an NDA does not make someone the permanent developer of a driver resultant from that NDA’s acceptance, instead it makes them the progenator of it. That developer can die, get bored and stop working on it, or just dissappear into the mist. There is nothing obligating the person to maintain the code after it’s creation.
If something is against your principles and you do it anyways, do you then not have that principle anymore?
Stop with the closed-source trolling, BSD supports the existance of closed source software, it holds nothing against it. However, OpenBSD does not support closed-source drivers, in fact, they are one of the only operating systems that flatly refuses them these days.
So, skipping the troll next time, how do you reconcile selling one’s beliefs out in order to support those very beliefs?
>NDAs are a good start to change the hardware mindset against open source.
Living in paradise together with some gurus leads probably to such a thinking. It would be nice, I have to confess – but wake up and have smart look at reality, it isn’t nice and shiny.
>It’s just that if you don’t agree to sign a NDA, you don’t even get a open source driver.
“Dancing with the Devil” is nowadays an alternative for open-source?
>I just can’t understand the *BSD position.
Freedom without any trade-offs. Sometimes you have to step down, if you’re mature to do so.
“They that can give up essential liberty to obtain a little temporary safety deserve neither liberty nor safety.”
-Benjamin Franklin
Living in paradise together with some gurus leads probably to such a thinking. It would be nice, I have to confess – but wake up and have smart look at reality, it isn’t nice and shiny.
And who is telling that is the people that thinks that the best way to get the hardware industry into the opensource world is to ask for full specs?
IF anything, starting with getting open source drivers out of a signed NDA is being realisting
“They that can give up essential liberty to obtain a little temporary safety deserve neither liberty nor safety”
As I said before, I support realistic open source driver development, in a realistic world where lots of hardware companies think that open source is evil. And in order to fix that, your plan is to sit down and ask for full specs to all the hardware companies in the world. Fine. I prefer to try to make them change their minds politely.
(BTW; do you realize that that kind of thinking is the one that many hardware companies producing open source drivers – “I deserve freedom to do what I want with my company”)
NDAs give control to companies over kernel device interfaces. And if the original author stops developing the driver the new one will have to sign a new NDA (if the company exists).
Too much risk and overhead. Don’t sign this satanic things.
I wonder about the reaction to this from the GPL Linux zealots posters, who frequently paint the Linux world as a defender of the OSS…
I’m not a zealot, which perhaps is why I am able to realize that nothing in either license makes any statement concerning how any relevant specifications for the covered work were obtained. The GPL doesn’t explicitly allow or prohibit obtaining specifications under NDA, and neither does the BSD. So let’s remove licensing from the discussion, because it simply isn’t relevant.
The issue at bar is whether it is better to suffer with inoperable hardware than to write OSS drivers with NDA specifications. You are free to draw your own conclusion, but to me it is clear that any pragmatist answers no. From the idealist perspective, it’s important to remember that the NDA facilitates a clean-room environment with respect to any non-signer. In other words, the NDA developer produces a relatively obscure OSS driver, which any non-NDA developer can reverse-engineer to produce an immaculately readable driver.
The way I look at it, is that this policy lets the Linux kernel community get its foot in the door. Once we say we’re friendly to the IP concerns of the hardware vendors, we can have an honest discussion about how the kernel community will respond to an intentionally obscured driver. Any obscure driver in the tree will gradually become transparent as the kernel community strives to achieve a clean implementation. So I don’t think many vendors will require obfuscation. I don’t even think many vendors will require an NDA. I think this will open the lines of communication and assuage the IP concerns of the hardware vendors.
The BSD community does this all the time, although they have to work really hard to get the obscure specs which they then have to re-implement. This agreement let’s the Linux community eliminate the first half of clean-room reverse-engineering and focus on the second.
Edited 2007-02-17 02:53
In other words, the NDA developer produces a relatively obscure OSS driver, which any non-NDA developer can reverse-engineer to produce an immaculately readable driver. […] Any obscure driver in the tree will gradually become transparent as the kernel community strives to achieve a clean implementation.
Right, but it could become a serious waste of time. Having to navigate with meaningless variable or function names with the complete absence of comments might not be mystifying as analysing binary outputs, but it would still be quite a chore. This is without mentioning the code would be highly vulnerable to security issues until it’s cleaned up.
Since there is no guarantee on the completeness or the accuracy of the documentation, a lone developer could be overwhelmed by the task… Of course, open documentation is not inherently superior, but you are not alone to figure out what is wrong with it! Furthermore, it could become difficult for developers under NDAs to collaborate with others on similar projects.
So I don’t think many vendors will require obfuscation. I don’t even think many vendors will require an NDA.
I don’t share this optimism. With the ongoing IP wars in the occidental world, vendors tend to be cautious. If they can put the blame on a leak on somebody, they will. Developers shouldn’t have to deal with this.
I think this will open the lines of communication and assuage the IP concerns of the hardware vendors.
It was a great idea to promote better collaboration with vendors, but I am still lukewarm at the idea of doing subjugation for using their products. It’s sad there is so little competition in the OS market.
I think you underestimate how hard it is to reverse-engineer a binary and how awful most hardware specifications are (if they exist at all). Figuring things out from an obfuscated C file is my idea of a fun weekend, but then again my job involves debugging a kernel debugger, so my perspective might be skewed.
Many hardware vendors, especially in the commodity market, don’t have natural language specifications for their products, even internally. The documentation is usually the Windows driver, and anything else is always out of date. I’ll take the obscure C file, you take the out-of-date documentation, and we’ll see who finishes first.
you see… it’s not about hurting companies, you know.
it’s about having something really open and free – for everyone.
And OpenBSD gets it right
My thoughts exactly…I wonder about the reaction to this from anti-GPL posters, who frequently paint BSD as “less radical” and more “corporate friendly.”
Depends on what the motivation for the anti-GPL is, philosophical, business or just plain well hating it for no other good reason than just hating it for the sake of it.
What pisses me off is the excuses used, the bullshit patent excuse that is thrown around – the simple fact is, the patent holder still gets payment, irrespective of whether the algorithm for the technology is known or not; the compounds of a given drug are known, and yet, if you make one which has been patented, you still have to pay royalties.
If Ati or Nvidia made the source code to their drivers available, the respective patent holders would still receive their royalties, and better still, Nvidia would have a legion of coders fixing up problems as they find them.
Its all about smoke, mirrors and bullshit – coders in their ivory towers not wanting anyone to see how hideous their code is and businessmen coming up with cock ‘n bull stories about so-called IP constraints to justify hiring legions of lawyers and papers shufflers.
Edited 2007-02-16 22:32
I don’t always agree with you, but here you’re right on the money…
There’s nothing to wonder about. BSD advocates are heartedly in favor of Free Software. They just don’t agree with the concept of copyleft. The software they release is as restriction free as practically possible. They have no interest in surrounding themselves with lawyers and license enforcement response teams.
Just because they have no interest in telling NVidia what to do, does not mean they don’t want a Free Software video driver.
Just because they have no interest in telling NVidia what to do
Bullshit. The BSD guys, especially Theo, tell hardware vendors what to do all the time, demanding open specifications. I applaud their efforts, but they go about it in the wrong way.
In contrast, the Linux community has come to the obvious conclusion that hardware vendors don’t like loudmouth revolutionaries like Theo telling them what to do. Instead we rephrase our “demands” in the form of an offer. The Linux community offers no-charge driver development pending your cooperation in providing specifications or a point-of-contact in your engineering department. It’s the same effort, but the language is turned on its head to sound more reasonable.
Effective communication gets you along in the world. Some engineering managers call this “soft skills,” and Theo and company don’t have them.
There’s nothing to wonder about. BSD advocates are heartedly in favor of Free Software.
I’m not questioning that, but the fact is that many people who make anti-GPL comments and say they prefer BSD in the same breath are not BSD contributors or free software enthusiasts, but rather people who want to sow discord within the free software world because they have interests in closed source software.
In short, many people who attack the GPL and pretend to laud the BSD license are not doing so out of altruism, but rather because of self-interest.
Ok, so let us just replace “more corporate friendly” with “more open”.
Linux is about open source software.
Is it? The more popular GNU/Linux gets, the bigger proportion of the userbase does not care about freedom; they care about getting their work done. The “ethical” geeks are only a small part of geeks in whole, and geeks are only a small part of the userbase. As time goes on, their percentage gets smaller still. This is the sad truth and should not be simply shrugged off.
The thing is, people want GNU/Linux to become more popular. The only way to do it (as empirical evidence suggests) is to listen to new users and users who have not yet begun to use GNU/Linux, and figure out what they want out of the system. More often than not, this is “I want to use my closed hardware.”
There seems to be a principle in the community that no inclusion of code is unholy if it can be fitted into the GPL, as this enables quick userbase growth, and it enables everyone to use whatever hardware they wish with GNU/Linux. Sadly, this trend has little to do with ensuring freedom; getting everything GPL-licensed is not the end, only the means, and it is not enough in itself.
In other words, I agree with and endorse OpenBSD developers.
It is strange that BSDians complain about this and not Linuxians.
Actually, I don’t find it strange at all. The BSDians are upset because they can’t use these drivers, since the GPL is incompatible with the BSD license. And they want to put the Linux devs under pressure to avoid NDAs so that reverse-engineering drivers is easier. Boo hoo.
The Linuxians aren’t complaining because this can only help Linux and the Linux community. Drivers are only a small part of the overall open-source ecosystem. And they are imho one of the rare cases where it makes sense for usability to trump maintainability every time, since the HW manufacturers themselves hardly maintain any kind of standards between hardware revisions.
Having more hardware supported means that more people use Linux, means that more open-source projects get exposure and more developers working on them, means that the open-source ecosystem in broadened and improved.
Insisting on open hardware specs will conversely only result in fewer people using/developing the entire operating system and its software.
Don’t get me wrong: open hardware specs are the way to go. But I really don’t think HW manufacturers are going to feel much pressure about this issue as long as Linux has such a small share of the desktop market.
Edited 2007-02-17 09:40
Theo, as always, has got a point. He presents it, as always, quite bluntly too.
Translation:
Theo thinks he’s right about everything,
and he’s also an asshole.
He’s right. The open source nv driver (for 2d onlyon nvidia cards) is apparently a mess right now, despite the code being open. It was given as is from nVidia (which is great) but has stagnated and is hard to work with.
If only the initial dev of a driver gets access to the spec, years on the driver will be a mess, just as nv is now.
Greg KH has the right idea pushing for open drivers, but he may be trying too hard and missing the longer term picture vis a vis NDAs.
Greg KH has the right idea pushing for open drivers, but he may be trying too hard and missing the longer term picture vis a vis NDAs.
GregKH doesn’t loves having to sign secret NDAs. Just like all the linux kernel developers. OpenBSD leaders are just FUding with this “linux developers love NDAs” stupid argument.
Nobody likes NDAs. However, if you have a better plan in order to get hardware companies into the opensource drivers world, tell me what’s that plan. A driver written through NDA is still a open source driver, and when companies realize that open source doesn’t bite, we may start pressuring them to get NDAs.
IOW: Open source drivers with NDA are much better than no driver at all, and are a step towards convincing hardware companies to fully support open source. Asking everything from the start makes that way harder to walk.
Edited 2007-02-17 02:03
When it comes to this issue of binary drivers, blobs, NDA’s and truly open drivers I would listen to the OpenBSD devs. They have been fighting the good fight for a long time in this arena, and they have done great work with wireless drivers. They may often be the “voice crying in the wilderness”, but it is a voice we should heed.
>I would listen to the OpenBSD devs. They have been fighting the good fight for a long time in this arena, and they have done great work with wireless drivers.
I agree and want to add: It is a shame that the Linux Hackers don’t support the OpenBSD Hacker in their fight toward free driver. If the Linux Hacker would hook up in this activity the voice would be even louder and probably even more successful.
Good drivers with well-commented notes on the driver structure and the reasons for the way in which something is implemented the way it is are a freaking blue-print to the hardware.
Oftentimes, the hardware makers themselves end up not having much better documentation because the driver is developed in an ad-hoc fast-paced manner and the only person that really understands it is the specific guy who wrote it for that hardware maker. When he leaves, the hardware makers is often in a bind. This happens less for enterprise hardware, but is a common situation with consumer-grade hardware.
Therefore, given that Linux has very qualified people writing the drivers, that these people will write good code and that lots of drivers were written with no documentation before through reverse-engineering and trial-and-error, it seems like the availability of Linux’s free software drivers will actually help the *BSD guys write their own because they will be able to use much of the knowledge gain from the Linux drivers.
Not to mention that Greg or anyone writing a Linux driver will be perfectly happy to answer questions about the code in the driver he/she wrote.
Would a completely documented piece of hardware released for everyone to benefit be better? Yes, it would, but we happen to live in a very imperfect world.
Edited 2007-02-16 22:21
it seems like the availability of Linux’s free software drivers will actually help the *BSD guys write their own because they will be able to use much of the knowledge gain from the Linux drivers.
It’s exactly the contrary. From where come from all the open source wifi drivers of Linux ?
-> From the reverse engineering of the OpenBSD Project.
It’s exactly the contrary. From where come from all the open source wifi drivers of Linux ?
You know, you can say exactly the same about almost every other driver category in the *BSD land.
I’m guessing the problem has to do with honoring NDAs. It might be entirely possible that you could write the driver but not be allowed to document it thoroughly because the documentation would be violating the NDA you agreed to in order to get the specs. Thus it wouldn’t be able to act as a blueprint as easily as you might think.
“it seems like the availability of Linux’s free software drivers will actually help the *BSD guys write their own because they will be able to use much of the knowledge gain from the Linux drivers.
Not to mention that Greg or anyone writing a Linux driver will be perfectly happy to answer questions about the code in the driver he/she wrote.”
Well, atleast in theory isn’t the code rather useless for the BSD people? Doesn’t the GPL make it impossible for BSD people to gain any knowledge (and therefor use) any part of the GPL:ed code in their drivers? (Shouldn’t any small part count?)
Sure the developer of the Linux driver might had been able to give a helping hand and share some information and knowledge about how it was done but then he was under NDA…
A better example than what I posted earlier: the Realtek wireless drivers.
The original author of the open source drivers disappeared and so the project was forked (no write access to the original repository). On the lists there one can read this:
“…I am interested to get deeper into the code…”
Response:
“It’s a big problem that the code isn’t documented and we need to do that. I don’t know how everything works and I think only one persons knows, the old developer of the code, but he is gone.
If you like to begin with writing a documentation and developing on the code it would be nice.
Realtek give developers access to their hardware documentation and I asked them for it some days ago, but they haven’t answered jet. You could also ask them for it.”
(from https://sourceforge.net/forum/forum.php?thread_id=1652282&forum_id=6… )
Now, a later message reveals that realtek did indeed send the documentation. But in the period before they did, the new devs were hamstrung in their efforts.
If in the course of “open” driver development an NDA was signed by the original dev who then disappeared, if no specs were sent out to later devs the driver would be severely disadvantaged moving forward. Realtek’s wireless drivers, before the new devs got ahold of the specs themselves, was a real world example.
I never thought I’d say this in a hundred gazillion years, but I agree with Theo. Sort of.
Kernel devs should not be signing NDA’s. Period. They can be a legal minefield in an already litigious environment. There is an inherent risk that those devs could taint future contributions that may be entirely unrelated to the NDA-encompassed project, and the point about hindering documentation and future support are valid.
Having said that, I’m also very cognizant of the fact that issues related to the concept of intellectual property are not going to simply disappear simply because the community dismisses them as invalid. Companies have investors, shareholders, regulators, predatory-competitors and above all else, overzealous legal departments, that they are held accountable to. Free software advocates in public forums rank somewhat near the bottom of the list, and customers are somewhere in the middle.
Properly structured NDA’s can possibly hold value if they can address the concerns of the corporate stakeholders without handcuffing developers; it is possible. If the linux kernel devs want access to proprietary information that will not be divulged without signed NDA’s, then those NDA’s should be signed by a responsible and accountable external organizations (such as the Linux Foundation) so that qualified developers can document the proprietary information in such a way that it provides enough information for developers to work with in terms of accessing and controlling hardware protocols and API’s without necessarily divulging proprietary specs or trade secrets.
The kernel developers (or anyone else) could use these specs to develop against, without the hindrance of signing NDA’s. The kernel devs (and linux itself) are isolated against claims of trade infringement if they choose to work on similar projects or drivers down the road, and by properly documenting the specs there’s no fear of a project dying because someone gets hit by a bus.
Of course, it’s not ideal. The hardware companies still ultimately control the information released, and may choose to inhibit full functionality. The kernel devs are still constrained by the information provided, but at least there’s no prohibition on future reverse engineering either.
Free software advocates will often advocate an all or nothing approach, which is noble and admirable. But for others, compromise is not necessarily a bad thing as long as it advances your ultimate objective without demanding too big a sacrifice.
I don’t think the idea of NDA’s being used as a tool to aid driver development is inherently bad, I’m just not sure Greg’s idea of developers themselves signing them is the best approach. Or even a good one.
* Hardware vendors don’t “hate” open source.
* Nobody uses “can’t reveal patented details” as an excuse for not providing hardware documentation
* If no open source developer ever signed an NDA you’d never have enough kernel developers to develop open source kernels
* Having the documentation, NDA-ed or not, is often not enough to do a driver
So, if there have to be NDAs for there to be open source kernels, how does OpenBSD get by?
So, if there have to be NDAs for there to be open source kernels, how does OpenBSD get by?
There don’t have to be NDAs for there to be open source kernels.
There have to be NDAs for the people who work on open source kernels to get paid for the work they do that gives them the opportunity to work on open source kernels.
If you’re a professional developer in this day and age you sign NDAs. As a minimum you sign the one that’s required as part of your employment contract.
That seems to be complete bullshit you’ve pulled out of your ass, kernel development does not require a company hire you, it requires you make code for the kernel.
One need not sign an NDA when you get a job and one need not have a job to programme for a kernel.
Professional software developers don’t have to sign NDAs, in this or any other age. Not all jobs involve NDAs.
You seem confused, or stupid, I don’t know which.
You seem confused, or stupid, I don’t know which.
You’re new around here, aren’t you?
kernel development does not require a company hire you, it requires you make code for the kernel.
kernel development requires eating, and eating requires a job.
most open source developers have day jobs as programmers.
One need not sign an NDA when you get a job and one need not have a job to programme for a kernel.
most programming jobs require at least the NDA you sign as a condition of employment, although I suspect many people don’t realize they’ve signed an NDA as part of getting their job.
Professional software developers don’t have to sign NDAs, in this or any other age. Not all jobs involve NDAs.
most companies require an NDA as a condition for employment for any knowledge worker.
If all those people who have signed NDAs were unable to work on open source, there wouldn’t be enough talent among the rest to reach critical mass for keeping a kernel development process alive.
> If all those people who have signed NDAs were unable to work on open source, there wouldn’t be enough talent among the rest to reach critical mass for keeping a kernel development process alive.
I say again, OpenBSD seems to being doing fine. Perhaps your precious development would be slowed, perhaps Linux development would be as slow as OpenBSD development, but it looks like OpenBSD’s development process is still ongoing.
I say again, OpenBSD seems to being doing fine. Perhaps your precious development would be slowed, perhaps Linux development would be as slow as OpenBSD development, but it looks like OpenBSD’s development process is still ongoing.
So? Most of the OpenBSD developers have signed NDAs. How would OpenBSD do if everyone of its developers who is employed as a software professions would have to stop working on it, because of a fear of NDAs?
But it’s a necessary evil and if it takes us a quantum leap closer to total hardware support which this does so be it. Damn the torpedoes, full speed ahead. We can sit on the sidelines and become a niche conversation piece like BSD or we can achieve total world domination, can’t do both.
I do agree that NDAs are something nobody likes, but that is so widespread it’s kind of inescapable. To do away with NDAs completely we’d have to completely change the corporate culture, and that’s a Herculean task at best!
On another note, this is what I love about F/OSS: the healthy debate of ideas. That in itself makes me appreciate it even more.
Signing and NDA doesn’t force you to write obfuscated code.
The obvious reason for signing the NDA is that you get to look at the entire specs of the hardware device (not just the bare minimum needed to interface an OS with it). This knowledge lets you write a better driver, and reduces the need for the company to redact proprietary information for the sake of the kernel dev. The driver that’s a product of this is not going to necessarily be a source-code blob. Don’t forget, a linux kernel developer is going to be doing this and the dev will quit if the terms do not match up with his (her?) ideology.
The whole point of this NDA business is to keep proprietary information secret while letting interface information be available to the kernel dev. If companies want to produce source-blobs, they’ll have to hire their own programmers and it’d be hard to push that into the mainline kernel.
theo is right, NDA’s are fugly, but if it matters in the free SOFTWARE perspective depends on what the NDA is for.
as presented, many companies may be too stupid or careless as to actually produce a set of the specifications required for driver developers, and may only have a bunch of crap, where some stuff reveal “intellectuel property”(which is stupid as it is, as it cant really protect them), and so if they sign an NDA, they may not disclose anything but whats needed in the driver perspective.. this we can accept.
i really hope greg wont do something stupid as to develop magic “open” drivers
Being a Linux driver developer for my company that sells hardware widgets I urge the community to look at the big picture and social tendencies before condemning anyones action when it comes to getting any kind of code support into Linux. One should consider a bend but don’t break attitude until your paradigm is the one that is in control.
Companies still operate under the crusty paradigm of supply and demamnd. The biz-ness dweebs still run the show (like it or not) and all they care about is what will make them money. The ‘new’ open source paradigm slaps the face of the old and anyone that has read Kuhn knows that the old paradigms usually have to die off with those that believe them before change can occur.
Linux is playing catch up and must do what it can to gain widespread adoption. This means vendor supported hardware and mainstream software before businesses will adopt Linux in large numbers. You will find that once businesses start using Linux the world’s user base will soon follow, this is how it works. Users (yes users) don’t want to learn and only do so when they are forced to (their job!). That means that Linux has to get mainstream software and hardware companies to buy into supporting Linux so the “users” don’t have to (re)learn because the biz-ness dweebs that are running the show are those same lazy users too. You can argue with this all you want but if you look at any corporation in America you will find 98% of employees are lazy, ignorant, and uninterested when it comes to computing. How many times have you heard “I just want it to work. I don’t care how it does it, just make it work how I’m used to.”
Because Windows still has the lock on the world’s PC market Linux has to chip away however it can. Greg is trying this through his free driver initiative. One could think I would be opposed to his actions because I am a compensated employee of a company that may use community services, and his actions may threaten my job. But that is not the case, I commend his actions because I can see the “Big Picture”!
Nothing more would please than to see every communitity developer be well compensated by the corporations of the world because their work drives every computer in across the globe. This mass independent contractor society will result due to wide-spread Linux adoption and no longer will it only apply to the elite such as Linus and friends. For this to happen you have to make Linux a value proposition to companies that supply hardware and software to the world’s computers.
Also be aware the computing world isn’t like it was in days past. Most solutions that were once non-existent already exist for users to do this or that. What the Linux community must now do is convince companies that provide those solutions to support the Linux OS in addition to Windows, et al. This is not easy due to Linux’s immaturity in the development arena (easy tools, GUIs, etc.), and small talent pool. It costs companies far more to support multiple operating systems.
At the URL provided the managing editor of Linux Today points out some very good information as to why specs are kept under lock and key and I urge you all to read it carefully. The mindset of JoeWidget CEO is what Linux must overcome.
http://www.linuxtoday.com/developer/2007021602926OPBZHW
Funny, the OpenBSD people seem to see a different, “big picture,” is yours bigger then, than the one I see?
Noone representing OpenBSD has ever, ever said they want a company to make drivers for them, they’ve said they want the documentation to do it themselves. So to get a driver in OpenBSD, it costs the amount of money it takes to host the documentation in digital form. I think if a company is making hardware, it probably has a web-budget, most do these days.
What Greg is doing is saying that that documentation isn’t needed, that it’s more important to simply have magic doing the work. That is so short sighted, it’s not even looking at a pixel in the big picture I see.
And that article is a pile of horseshit, complete garbage.
Wow–this quote from the article blew my mind:
“Paradoxically, the advent of Vista has given many hardware vendors a new source of revenue that will make Linux even less attractive to them. Vista, as we know, is such an inefficient resource hog, that only high-end hardware will work well in it. Thus, many users shifting to Vista will need whole new machines or new devices to make up the performance difference. One has to wonder if that’s what Microsoft has in mind every time it delivers a new, bigger version of Windows. Keep loyal to us, they may say to vendors, and we’ll get you a steady revenue cycle. Actually, no one wonders about this; it’s pretty obvious.”
…And here I was always thinking the Microsoft coders were just careless or incompetent….
I can’t argue with the point that NDA’s don’t offer much more freedom when applied to source code either.
Being a heavy GPL V3 proponent, I think the only real restrictions we need are those that prevent human greed and locking up tech markets through the Microsoft/Intel cartel.
My only opposition to the BSD camp is that they do not see a problem with human greed or the problems my industry has in the USA and actually seek to enhance the problem with the non restrictive license they have in place.
What has to happen is the abolishment of the Patent system in the industrial computing complex.
Without completely open hardware specs to write software against, we are going to end up with really poorly qualified people writing these drivers and all of us suffering for it.
Its really quite sad and it is all due to human greed and nothing else.
-Hack
It’s a good start, when BSD and Linux became more popular in desktop/laptops world, we can push hardware vendors to do what we need, till then, they wont care about Open Source OS at all.