Linux in a binary world... a doomsday scenario
Quoted 5 lines · Greg KH
For people to think that the kernel developers are just "too dumb" to make a stable kernel api (and yes, I've had people accuse me of this many times to my face[1]) shows a total lack of understanding as to _why_ we change the in-kernel api all the time. Please see
Documentation/stable_api_nonsense.txtfor details on this.
I read this doc, and it doesn't make your case any clearer, on the contrary!
But first, your work to the kernel represents a not so dumb contribution, especially the replacement of devfs. Thanks!
Now, to call a stable api nonsense is nonsense. Really, only a _stable_ api is worth to be considered an API. Think about it.
The only advantage of not offering a _stable_ api is to enforce some weird kind of copy protection scheme, because let's face it:
An API would benefit everybody, even those that may take advantage of it.
So to limit the kernel by making it awkward to interact with it, because somebody may take advantage, is a rather paranoid way of doing things.
Things are bad enough the kernel being monolithic, and then inhibiting a sane API to develop may only serve to delay the competitiveness of the kernel.
Loose the paranoia and prove GNU/Linux can stand on its own.
Thanks!
--
Al
Quoted 7 lines · Al Boldi
Quoted 5 lines · Greg KH
For people to think that the kernel developers are just "too dumb" to make a stable kernel api (and yes, I've had people accuse me of this many times to my face[1]) shows a total lack of understanding as to _why_ we change the in-kernel api all the time. Please see
Documentation/stable_api_nonsense.txtfor details on this.
Quoted 7 lines
I read this doc, and it doesn't make your case any clearer, on the contrary!
But first, your work to the kernel represents a not so dumb contribution, especially the replacement of devfs. Thanks!
Now, to call a stable api nonsense is nonsense. Really, only a _stable_ api is worth to be considered an API. Think about it.
a stable api/abi for the linux kernel would take at least 2 years to develop. The current API is not designed for stable-ness, a stable API needs stricter separation between the layers and more opaque pointers etc etc.
There is a price you pay for having such a rigid scheme (it arguably has advantages too, those are mostly relevant in a closed source system tho) is that it's a lot harder to implement improvements. Linux isn't so much designed as evolved, and in evolution, new dominant things emerge regularly. A stable API would prevent those from even coming into existing, let alone become dominant and implemented. The price linux pays for this is that code needs changing all the time. On the other hand.. the GPL gives you that code so that you can do that...
Quoted 14 lines · Arjan van de Ven
Quoted 13 lines · Al Boldi
Quoted 5 lines · Greg KH
For people to think that the kernel developers are just "too dumb" to make a stable kernel api (and yes, I've had people accuse me of this many times to my face[1]) shows a total lack of understanding as to _why_ we change the in-kernel api all the time. Please see
Documentation/stable_api_nonsense.txtfor details on this.I read this doc, and it doesn't make your case any clearer, on the contrary!
But first, your work to the kernel represents a not so dumb contribution, especially the replacement of devfs. Thanks!
Quoted 7 lines
Quoted 2 lines
Now, to call a stable api nonsense is nonsense. Really, only a _stable_ api is worth to be considered an API. Think about it.
a stable api/abi for the linux kernel would take at least 2 years to develop. The current API is not designed for stable-ness, a stable API needs stricter separation between the layers and more opaque pointers etc etc.
True. But it would be time well spent.
Quoted 3 lines
There is a price you pay for having such a rigid scheme (it arguably has advantages too, those are mostly relevant in a closed source system tho) is that it's a lot harder to implement improvements.
This is a common misconception. What is true is that a closed system is forced to implement a stable api by nature. In an OpenSource system you can just hack around, which may seem to speed your development cycle when in fact it inhibits it.
Quoted 3 lines
Linux isn't so much designed as evolved, and in evolution, new dominant things emerge regularly. A stable API would prevent those from even coming into existing, let alone become dominant and implemented.
GNU/OpenSource is unguided by nature. A stable API contributes to a guided development that is scalable. Scalability is what leads you to new heights, or else could you imagine how ugly it would be to send this message using asm?
Thanks!
--
Al
Quoted 11 lines · Al Boldi
Quoted 5 lines · Arjan van de Ven
a stable api/abi for the linux kernel would take at least 2 years to develop. The current API is not designed for stable-ness, a stable API needs stricter separation between the layers and more opaque pointers etc etc.
True. But it would be time well spent.
Who's time would be well spent?
Not mine because I don't want a stable API. Not mine because I don't use binary drivers and I don't care to encourage them. [that is, unless you manage to convince me below ;)]
Anyone else is free to fork the kernel and develop their own stable API for it. I don't think I would go so far as to call that time well spent, however.
Quoted 8 lines
Quoted 4 lines
There is a price you pay for having such a rigid scheme (it arguably has advantages too, those are mostly relevant in a closed source system tho) is that it's a lot harder to implement improvements.
This is a common misconception. What is true is that a closed system is forced to implement a stable api by nature. In an OpenSource system you can just hack around, which may seem to speed your development cycle when in fact it inhibits it.
How? I'm quite willing to listen, but throwing around words like 'guided development' and 'scalability' doesn't do anything. How does the lack of a stable API inhibit my kernel development work, exactly?
Quoted 7 lines
Quoted 4 lines
Linux isn't so much designed as evolved, and in evolution, new dominant things emerge regularly. A stable API would prevent those from even coming into existing, let alone become dominant and implemented.
GNU/OpenSource is unguided by nature.
I've got a fairly good idea of what work I'm doing, and what I'm planning to do, long term goals, projects, etc. What would be the key differences with "non-GNU/OpenSource" development that would make you say they are not unguided by nature?
Quoted 3 lines
A stable API contributes to a guided
development that is scalable. Scalability is what leads you to new heights, or else could you imagine how ugly it would be to send this message using asm?
Let's not bother with bad analogies and stick to facts. Do you know how many people work on the Linux kernel? And how rapidly the source tree changes? Estimates of how many bugs we have? Comparitive numbers from projects with stable APIs? That would be very interesting.
Thanks,
Nick
Send instant messages to your online friends http://au.messenger.yahoo.com
Quoted 7 lines · Nick Piggin
Quoted 6 lines · Al Boldi
Quoted 4 lines · Arjan van de Ven
a stable api/abi for the linux kernel would take at least 2 years to develop. The current API is not designed for stable-ness, a stable API needs stricter separation between the layers and more opaque pointers etc etc.
Quoted 7 lines
Quoted 1 line
True. But it would be time well spent.
Who's time would be well spent?
Not mine because I don't want a stable API. Not mine because I don't use binary drivers and I don't care to encourage them. [that is, unless you manage to convince me below ;)]
The fact that somebody may take advantage of a stable API should not lead us to reject the idea per se.
Quoted 2 lines
Anyone else is free to fork the kernel and develop their own stable API for it.
That would be sad.
The objective of a stable API would be to aid the collective effort and not to divide it.
Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
There is a price you pay for having such a rigid scheme (it arguably has advantages too, those are mostly relevant in a closed source system tho) is that it's a lot harder to implement improvements.
Quoted 8 lines
Quoted 4 lines
This is a common misconception. What is true is that a closed system is forced to implement a stable api by nature. In an OpenSource system you can just hack around, which may seem to speed your development cycle when in fact it inhibits it.
How? I'm quite willing to listen, but throwing around words like 'guided development' and 'scalability' doesn't do anything. How does the lack of a stable API inhibit my kernel development work, exactly?
If you are working alone a stable API would be overkill. But GNU/Linux is a collective effort, where stability is paramount to aid scalability.
I hope the concepts here are clear.
Quoted 10 lines
Quoted 5 lines
Quoted 3 lines
Linux isn't so much designed as evolved, and in evolution, new dominant things emerge regularly. A stable API would prevent those from even coming into existing, let alone become dominant and implemented.
GNU/OpenSource is unguided by nature.
I've got a fairly good idea of what work I'm doing, and what I'm planning to do, long term goals, projects, etc. What would be the key differences with "non-GNU/OpenSource" development that would make you say they are not unguided by nature?
The same goes for OpenSource in general, but GNU/OpenSource has a larger community and therefore is in greater need of a stable API.
Quoted 9 lines
Quoted 4 lines
A stable API contributes to a guided
development that is scalable. Scalability is what leads you to new heights, or else could you imagine how ugly it would be to send this message using asm?Let's not bother with bad analogies and stick to facts. Do you know how many people work on the Linux kernel? And how rapidly the source tree changes? Estimates of how many bugs we have? Comparitive numbers from projects with stable APIs? That would be very interesting.
You got me here! It's really common sense as in:
stability breeds scalability, and instability breeds chaos.
Quoted 1 line · Arjan van de Ven
I think Linux proves you wrong (and a bit of a troll to be honest ;)
No troll! Just being IMHO. I hope that's OK?
Of course, if your aim is not to be scalable then please ignore this message as it will not have any meaning.
Thanks!
--
Al
Quoted 8 lines
Quoted 3 lines
Anyone else is free to fork the kernel and develop their own stable API for it.
That would be sad.
The objective of a stable API would be to aid the collective effort and not to divide it.
I think you missed how linux development works. Things fork all the time. The unsuccessful forks die. The successful ones join the "main line" again. Darwinism at work.
You're free to put your coding where your mouth is and design and implement a stable API. If it's a success.. it'll get there. If it's not.. no harm done to the rest.
Quoted 4 lines
If you are working alone a stable API would be overkill. But GNU/Linux is a collective effort, where stability is paramount to aid scalability.
I hope the concepts here are clear.
I think I don't get how you come from "stable API" to "aid scalability" in the light that the current non-API doesn't seem to prevent scalability to the size linux development is today.
Quoted 7 lines
Quoted 4 lines
I've got a fairly good idea of what work I'm doing, and what I'm planning to do, long term goals, projects, etc. What would be the key differences with "non-GNU/OpenSource" development that would make you say they are not unguided by nature?
The same goes for OpenSource in general, but GNU/OpenSource has a larger community and therefore is in greater need of a stable API.
again you skip a step. I see how a "large community" leads to "needs a visible API". The leap to "need stable API" I don't see in practice.
Quoted 4 lines
Quoted 1 line · Arjan van de Ven
I think Linux proves you wrong (and a bit of a troll to be honest ;)
No troll! Just being IMHO. I hope that's OK?
I hope you're also willing to put your effort where your words are, otherwise you are trolling to a large degree.
Quoted 7 lines · Al Boldi
Quoted 5 lines · Nick Piggin
Quoted 2 lines · Al Boldi
True. But it would be time well spent.
Quoted 9 lines
Quoted 5 lines
Who's time would be well spent?
Not mine because I don't want a stable API. Not mine because I don't use binary drivers and I don't care to encourage them. [that is, unless you manage to convince me below ;)]
The fact that somebody may take advantage of a stable API should not lead us to reject the idea per se.
Of course not, but the fact that they do nothing to help us means that it doesn't carry a lot of weight (IMO, of course).
So: who's time well spent?
Quoted 9 lines
Quoted 3 lines
Anyone else is free to fork the kernel and develop their own stable API for it.
That would be sad.
The objective of a stable API would be to aid the collective effort and not to divide it.
As Arjan said, this is how kernel development works. I was using it to highlight the fact that nobody has done so yet, which gives some indication that it is not time well spent.
Quoted 5 lines
Quoted 5 lines
Quoted 4 lines
This is a common misconception. What is true is that a closed system is forced to implement a stable api by nature. In an OpenSource system you can just hack around, which may seem to speed your development cycle when in fact it inhibits it.
Quoted 9 lines
Quoted 3 lines
How? I'm quite willing to listen, but throwing around words like 'guided development' and 'scalability' doesn't do anything. How does the lack of a stable API inhibit my kernel development work, exactly?
If you are working alone a stable API would be overkill. But GNU/Linux is a collective effort, where stability is paramount to aid scalability.
I hope the concepts here are clear.
No, they're not. I see no reason why your conjecture would be true and you have failed to provide even any theories as to why it might be. What's more, I'm not even clear what you mean by the scalability of a development process. So, please elaborate -- this is not a rhetorical question because I'm interested as to why you think this is the case, and I have not had much experience with closed software development.
Quoted 10 lines
Quoted 6 lines
Quoted 1 line
GNU/OpenSource is unguided by nature.
I've got a fairly good idea of what work I'm doing, and what I'm planning to do, long term goals, projects, etc. What would be the key differences with "non-GNU/OpenSource" development that would make you say they are not unguided by nature?
The same goes for OpenSource in general, but GNU/OpenSource has a larger community and therefore is in greater need of a stable API.
Yes, the same goes for OpenSource in general, fine. But what I'm asking
is: how is non-OpenSource different? What can we do better? How can we learn from them?
Quoted 9 lines
Quoted 4 lines
Let's not bother with bad analogies and stick to facts. Do you know how many people work on the Linux kernel? And how rapidly the source tree changes? Estimates of how many bugs we have? Comparitive numbers from projects with stable APIs? That would be very interesting.
You got me here! It's really common sense as in:
stability breeds scalability, and instability breeds chaos.
But you might not be far wrong in saying that Linux has one of the most chaotic and scalable development processes in the world.
We have unstable APIs, but IMO we have a great and stable software.
Quoted 7 lines
Quoted 1 line · Arjan van de Ven
I think Linux proves you wrong (and a bit of a troll to be honest ;)
No troll! Just being IMHO. I hope that's OK?
That's fine, but Linux and the development process is a personal achievement and creation of many here, so you have to try to be respectful :)
Quoted 2 lines
Of course, if your aim is not to be scalable then please ignore this message as it will not have any meaning.
I think most believe what I do: that our development model is scalable (scalability seems to be the least of its worries), and that unstable APIs are not a bad thing.
Everybody is also open to try to improve, however "stability breeds scalability, and instability breeds chaos" is simply not "common sense", so please explain and justify it before going further.
Signature · 3 lines
SUSE Labs, Novell Inc. Send instant messages to your online friends http://au.messenger.yahoo.com
Quoted 2 lines · Al Boldi
The fact that somebody may take advantage of a stable API should not lead
us to reject the idea per se.
True. But then nobody said the idea was rejected for that reason, just that supporting binary drivers is not a compelling reason to embrace a stable API. In other words, supporting binary drivers is not nearly as important as other factors which would be harmed by a stable API.
Quoted 2 lines
The objective of a stable API would be to aid the collective effort and not to divide it.
The collective effort seems to be doing just fine without it.
Quoted 4 lines
If you are working alone a stable API would be overkill. But GNU/Linux is a collective effort, where stability is paramount to aid scalability.
I hope the concepts here are clear.
No, it's not clear what you mean by scalability. What is it exactly that
you think would be more scalable? As has been mentioned already, there
is no better example today of scalable development than the Linux kernel. So, I don't think you've laid out at all what it is you're talking about.
Quoted 4 lines
No troll! Just being IMHO. I hope that's OK?
Of course, if your aim is not to be scalable then please ignore this message as it will not have any meaning.
The linux kernel development model scales very well. Linux itself scales from the smallest embedded processors to the largest parallel computing farms today; all without a stable internal API. So you've failed to make a case that there is a problem for which a stable API is the solution.
Cheers,
Sean
Quoted 20 lines · Al Boldi
Quoted 17 lines · Nick Piggin
Quoted 12 lines · Al Boldi
Quoted 6 lines · Arjan van de Ven
a stable api/abi for the linux kernel would take at least 2 years to develop. The current API is not designed for stable-ness, a stable API needs stricter separation between the layers and more opaque pointers etc etc.
True. But it would be time well spent.
Who's time would be well spent?
Quoted 9 lines
Quoted 5 lines
Not mine because I don't want a stable API. Not mine because I don't use binary drivers and I don't care to encourage them. [that is, unless you manage to convince me below ;)]
The fact that somebody may take advantage of a stable API should not lead us to reject the idea per se.
It is all about advantages and disadvantages.
Disadvantages of a stable API:
* It encourages binary-only drivers, while we prefer source drivers. Changing the API often and without warning is one way of hampering binary-only driver development without harming open-source drivers.
* A stable API isn't really possible. There will be revisions due to new compilers, new processors, new needs. So the only question is how often do we change. Hanging onto an obsolete API too long will hamper _kernel_ development and performance.
Example: smp changed a lot of things. The old idea
that cli/sti was a way of implementing a critical section had to go.
To argue for a stable API then, you need to come up with advantages, and they have to outweigh the disadvantages too.
Do a stable API save us work? No, because whoever changes the API also fixes all in-kernel users of said API. Some API changes, like using more or less register parameters, don't even need to fix API users as the compiler does it all.
Outside users we don't care about at all, because they are all welcome to get their driver in. (Assuming it is useful and the code quality is good...)
Quoted 10 lines
Quoted 4 lines
Anyone else is free to fork the kernel and develop their own stable API for it.
That would be sad.
The objective of a stable API would be to aid the collective effort and not to divide it.
Forks are not a problem. Anything useful in a fork will usually be merged back sooner or later. And think about the "normal" development process: If I were to write a driver, I would get the kernel source, make my driver, then submit it. In the meantime, I effectively have my own short-lived fork.
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 5 lines
There is a price you pay for having such a rigid scheme (it arguably has advantages too, those are mostly relevant in a closed source system tho) is that it's a lot harder to implement improvements.
This is a common misconception. What is true is that a closed system is forced to implement a stable api by nature. In an OpenSource system you can just hack around, which may seem to speed your development cycle when in fact it inhibits it.
Quoted 9 lines
Quoted 5 lines
How? I'm quite willing to listen, but throwing around words like 'guided development' and 'scalability' doesn't do anything. How does the lack of a stable API inhibit my kernel development work, exactly?
If you are working alone a stable API would be overkill. But GNU/Linux is a collective effort, where stability is paramount to aid scalability.
This doesn't actually hold when the source is available for all to get and update. The source API doesn't change so often, so it is time enough to develop a source driver without spending all the time on adapting to the source API. Once you get the driver in, you no longer have to keep up.
The binary api can change several times with every revision, with no impact on open-source developers. So, no need to stabilize it. Specs already says that a driver has to be compiled for the kernel it is used with - a binary driver working with two releases (even concecutive releases) are pure luck. So a binary vendor has to at least compile for every release (and every supported platform). If the source api changes too, then there is some programming to do as well. Both of these have a price, and there is the hope that more will see the light - that they can support linux fully without these costs by going open source.
Quoted 11 lines
Quoted 7 lines
I've got a fairly good idea of what work I'm doing, and what I'm planning to do, long term goals, projects, etc. What would be the key differences with "non-GNU/OpenSource" development that would make you say they are not unguided by nature?
The same goes for OpenSource in general, but GNU/OpenSource has a larger community and therefore is in greater need of a stable API.
A large community may find some kind of stability useful, the line does not have to be drawn at the binary api level though. The source API is much more stable than the binary API. And source changes is usually only withing some subsytem. I.e. a change in the pci driver API don't affect filesystem drivers and so on.
Quoted 15 lines
Quoted 8 lines
Quoted 8 lines
A stable API contributes to a guided
development that is scalable. Scalability is what leads you to new heights, or else could you imagine how ugly it would be to send this message using asm?Quoted 6 lines
Let's not bother with bad analogies and stick to facts. Do you know how many people work on the Linux kernel? And how rapidly the source tree changes? Estimates of how many bugs we have? Comparitive numbers from projects with stable APIs? That would be very interesting.
Quoted 4 lines
You got me here! It's really common sense as in:
stability breeds scalability, and instability breeds chaos.
This saying doesn't necessarily apply to an API in a open-source project. Especially not when talking about an internal API. The kernel has an external binary API that is stable, it is the syscall interface.
Quoted 12 lines
Quoted 3 lines · Arjan van de Ven
I think Linux proves you wrong (and a bit of a troll to be honest ;)
No troll! Just being IMHO. I hope that's OK?
Of course, if your aim is not to be scalable then please ignore this message as it will not have any meaning.
Another option is that your assumption about "stability as a requirement for scalability" is wrong at least in case of the kernel. The kernel development scales very well so far. I can't see any delays caused by developers trying to keep up with a change in binary APIs. Well, except a handful of closed source vendors, but that is more or less intentional. If they get tired, they can hand in their source.
Helge Hafting
Quoted 5 lines
Disadvantages of a stable API:
* It encourages binary-only drivers, while we prefer source drivers. Changing the API often and without warning is one way of hampering binary-only driver development without harming open-source drivers.
You are really shooting yourself in the foot here.
Quoted 2 lines
Do a stable API save us work? No, because whoever changes the API also fixes all in-kernel users of said API.
That's very inefficient.
Quoted 2 lines
how is non-OpenSource different? What can we do better? How can we learn from them?
Pretty much nothing, except for taking advantage of their precooked interconnectivity api's, in which they excel in abstracting them pretty well.
Quoted 26 lines
Quoted 4 lines
If you are working alone a stable API would be overkill. But GNU/Linux is a collective effort, where stability is paramount to aid scalability.
I hope the concepts here are clear.
No, it's not clear what you mean by scalability. What is it exactly that
you think would be more scalable? As has been mentioned already, there
is no better example today of scalable development than the Linux kernel. So, I don't think you've laid out at all what it is you're talking about.I think I don't get how you come from "stable API" to "aid scalability" in the light that the current non-API doesn't seem to prevent scalability to the size linux development is today.
The linux kernel development model scales very well. Linux itself scales from the smallest embedded processors to the largest parallel computing farms today; all without a stable internal API. So you've failed to make a case that there is a problem for which a stable API is the solution.
Another option is that your assumption about "stability as a requirement for scalability" is wrong at least in case of the kernel. The kernel development scales very well so far. I can't see any delays caused by developers trying to keep up with a change in binary APIs. Well, except a handful of closed source vendors, but that is more or less intentional. If they get tired, they can hand in their source.
Quoted 3 lines
I think most believe what I do: that our development model is scalable (scalability seems to be the least of its worries), and that unstable APIs are not a bad thing.
Don't mistake scalability for manageability/mantainability or flexibility. Scalability is more, much more. It's about extendability and reusability built on a solid foundation that may be stacked. Layers upon layers, the sky is the limit. Stability is the key to unlock this scalability.
Quoted 5 lines
Quoted 1 line
No troll! Just being IMHO. I hope that's OK?
That's fine, but Linux and the development process is a personal achievement and creation of many here, so you have to try to be respectful :)
Sorry! Can you point out which part was offending?
Thanks!
--
Al
Quoted 6 lines · Al Boldi
Don't mistake scalability for manageability/mantainability or flexibility. Scalability is more, much more. It's about extendability and reusability built on a solid foundation that may be stacked. Layers upon layers, the sky is the limit. Stability is the key to unlock this scalability.
There is a game, called "bullsh*t bingo" where you have bunch of buzzwords on you scorecard and you cross them out as you sneak them in conversation. Well, I think you just have won a round.
--
Dmitry
Quoted 8 lines · Al Boldi
Quoted 2 lines
how is non-OpenSource different? What can we do better? How can we learn from them?
Pretty much nothing, except for taking advantage of their precooked interconnectivity api's, in which they excel in abstracting them pretty
well.
Sorry you are just WRONG here. If you wanted to do low latency audio on Windows 4 years ago you were fucked because the kernel mixer adds 30ms of latency and there's no API to bypass it! Haha, you lose.
Eventually Cakewalk figured out an undocumented unsupported method called "Kernel Streaming" to bypass the kernel mixer. God knows how many man hours were wasted on this problem.
Please drop your ridiculous assertion that stable APIs don't impede progress. To create an stable API that would support new and innovative future applications would require a LOT of foresight. It's MUCH easier to just change the API when someone comes up with an application the old one can't support.
Lee
Quoted 4 lines · Al Boldi
Don't mistake scalability for manageability/mantainability or flexibility. Scalability is more, much more. It's about extendability and reusability built on a solid foundation that may be stacked. Layers upon layers, the sky is the limit. Stability is the key to unlock this scalability.
You know, Lehrer had done that one better (see, e.g.,
http://www.guntheranderson.com/v/data/whenyoua.htm)
Quoted 9 lines · Al Boldi
Quoted 5 lines
Disadvantages of a stable API:
* It encourages binary-only drivers, while we prefer source drivers. Changing the API often and without warning is one way of hampering binary-only driver development without harming open-source drivers.You are really shooting yourself in the foot here.
Replying to different people in the same email gets confusing.
Quoted 2 lines
Don't mistake scalability for manageability/mantainability or flexibility. Scalability is more, much more. It's about extendability and reusability built on a solid foundation that may be stacked. Layers upon layers, the sky is the limit. Stability is the key to unlock this scalability.
You're just completely making that all up with no reasons or basis. What's more it doesn't even mean anything. It is quite obvious that you have zero real arguments as to why a stable API is good. So let's just leave it at that.
Nick
Send instant messages to your online friends http://au.messenger.yahoo.com
Quoted 11 lines · Al Boldi
Quoted 7 lines
Disadvantages of a stable API:
* It encourages binary-only drivers, while we prefer source drivers. Changing the API often and without warning is one way of hampering binary-only driver development without harming open-source drivers.You are really shooting yourself in the foot here.
Only if supporting binary-only drivers is somehow considered important/useful. I don't believe so - so I don't shoot my foot here. :-)
Quoted 8 lines
Quoted 4 lines
Do a stable API save us work? No, because whoever changes the API also fixes all in-kernel users of said API.
That's very inefficient.
Wrong. It means that whoever want to change an API don't do so too lightly, because there certainly is some work involved. Even if it often only is a big "grep" followed up by some trivial editing. So, API change only when there is a win offsetting this work.
Such a process may seem inefficient if one were to schedule that work among a limited workforce. They had better not waste their time as that block further options for profit. But only _companies_ work that way. The kernel is different. There are lots and lots of people, each working on their favourite part. (Which is one reason why development scales so well.)
If someone does a time-consuming api change, then they aren't free to do other work. But if they don't do that api change - you can't schedule other work for them anyway because they aren't employees. They are volunteers, their work don't cost any but it is also only for themselves to decide what they work on.
So the usual rules or common sense about work management in a company do not apply. Each patch is a gift you can't trade for something else.
Quoted 9 lines
Quoted 4 lines
how is non-OpenSource different? What can we do better? How can we learn from them?
Pretty much nothing, except for taking advantage of their precooked interconnectivity api's, in which they excel in abstracting them pretty well.
[...]
Quoted 3 lines
Don't mistake scalability for manageability/mantainability or flexibility.
Well, if we have manageability, maintainability and flexibility then we are very well off, even if it doesn't fit your definition of scalability.
Quoted 2 lines
Scalability is more, much more. It's about extendability and reusability built on a solid foundation that may be stacked.
Again: Code reuse is nice, or even necessary, with a limited and expensive workforce. It is not a concern with an unlimited free workforce though. If some volunteer makes an improvement by doing a big rewrite - well, the job gets done and nobody have to pay him. This works. And you can't
get they guy to do something you find more useful "instead". Maintainers can refuse patches of course - this usually cause people to work less on linux rather than working more efficiently on linux. So even a "lot of work for only a little gain" type patch is taken, if it is technically sound. Because the time couldn't be better spent anyway, so it wasn't wasted.
Quoted 3 lines
Layers upon layers, the sky is the limit. Stability is the key to unlock this scalability.
I consider too many stacked layers inefficient. Keep it simple . . .
Helge Hafting
Quoted 16 lines · Helge Hafting
Quoted 2 lines · Al Boldi
Scalability is more, much more. It's about extendability and reusability built on a solid foundation that may be stacked.
Again: Code reuse is nice, or even necessary, with a limited and expensive workforce. It is not a concern with an unlimited free workforce though. If some volunteer makes an improvement by doing a big rewrite - well, the job gets done and nobody have to pay him. This works. And you can't
get they guy to do something you find more useful "instead". Maintainers can refuse patches of course - this usually cause people to work less on linux rather than working more efficiently on linux. So even a "lot of work for only a little gain" type patch is taken, if it is technically sound. Because the time couldn't be better spent anyway, so it wasn't wasted.
Quoted 4 lines
Quoted 2 lines
Layers upon layers, the
sky is the limit. Stability is the key to unlock this scalability.I consider too many stacked layers inefficient. Keep it simple . . .
True. But they are necessary to reach higher grounds.
Think about it.
Thanks!
--
Al
Quoted 4 lines · Al Boldi
Quoted 1 line · Arjan van de Ven
There is a price you pay for having such a rigid scheme (it arguably has advantages too, those are mostly relevant in a closed source system though) is that it's a lot harder to implement improvements.
This is a common misconception. What is true is that a closed system is forced to implement a stable api by nature. In an OpenSource system you can just hack around, which may seem to speed your development cycle when in fact it inhibits it.
This is _not_ the way Linux works. We don't have a stable API _precisely_ so we don't have to "hack around" our API. When the API is broken, we fix the API, therefore it doesn't get "hacked around" nearly as much as a so-called "Stable API" would be. The development cycle is *accelerated* by the fact that an important API changes are _OK_.
Quoted 3 lines
Quoted 1 line
Linux isn't so much designed as evolved, and in evolution, new dominant things emerge regularly. A stable API would prevent those from even coming into existing, let alone become dominant and implemented.
GNU/OpenSource is unguided by nature. A stable API contributes to a guided development that is scalable.
Wrong again. "Guided" implies that some overall authority controls everything that goes on, which is inherently unscalable. Look at how inefficient all the governments are! Look at how inefficient Linux kernel development was before BK and git! When Linus had to deal with the thousands of patches individually, that was the development bottleneck. As it is now, the merging work that Linus alone used to do is now divided up across a combination of Andrew Morton, Greg KH, and many valuable others (who can't all be listed without making this message overflow the mailing list limits).
Linux development scales _now_ better than any other software (open _OR_ closed) on the planet; recent patches from 2.6.X to 2.6.X+1-rc1 are 25MB in size and constantly growing. If you can come up with a development model that works as well and prove it in production, then good for you. I don't expect, however, to see any closed-source project come close to the rate of production of Linux; even _Microsoft_ couldn't afford as many man-hours on a single codebase for long.
Cheers,
Kyle Moffett
--
Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.
-- Brian Kernighan
Quoted 18 lines · Al Boldi
Quoted 17 lines · Arjan van de Ven
Quoted 15 lines · Al Boldi
Quoted 5 lines · Greg KH
For people to think that the kernel developers are just "too dumb" to make a stable kernel api (and yes, I've had people accuse me of this many times to my face[1]) shows a total lack of understanding as to _why_ we change the in-kernel api all the time. Please see
Documentation/stable_api_nonsense.txtfor details on this.I read this doc, and it doesn't make your case any clearer, on the contrary!
But first, your work to the kernel represents a not so dumb contribution, especially the replacement of devfs. Thanks!
Now, to call a stable api nonsense is nonsense. Really, only a _stable_ api is worth to be considered an API. Think about it.
Quoted 6 lines
Quoted 4 lines
a stable api/abi for the linux kernel would take at least 2 years to develop. The current API is not designed for stable-ness, a stable API needs stricter separation between the layers and more opaque pointers etc etc.
True. But it would be time well spent.
feel free to spend your time on it, you seem to consider it well spent time. A lot of us don't, so we're not going to spend our time on it....
Quoted 5 lines
Quoted 3 lines
There is a price you pay for having such a rigid scheme (it arguably has advantages too, those are mostly relevant in a closed source system tho) is that it's a lot harder to implement improvements.
This is a common misconception.
a stable API is more rigid, that is not and can't be a misconception.
Quoted 4 lines
What is true is that a closed system is
forced to implement a stable api by nature. In an OpenSource system you can just hack around, which may seem to speed your development cycle when in fact it inhibits it.
in practice it doesn't. The kernel drivers are GPL, and API changes when needed just happen, all callers are fixed. The alternative would be a "crooked" API which needs workarounds on both sides. No thanks.
Quoted 9 lines
Quoted 4 lines
Linux isn't so much designed as evolved, and in evolution, new dominant things emerge regularly. A stable API would prevent those from even coming into existing, let alone become dominant and implemented.
GNU/OpenSource is unguided by nature. A stable API contributes to a guided development that is scalable. Scalability is what leads you to new heights, or else could you imagine how ugly it would be to send this message using asm?
I think Linux proves you wrong (and a bit of a troll to be honest ;)
Anyway, it's an open system, if you think something should happen... you can make it happen by contributing and then defending it. If it's the right thing, it'll then happen.
On Thu, 2005-12-15 at 00:13 +0300, Al Boldi wrote:
[....]
Quoted 2 lines
Now, to call a stable api nonsense is nonsense. Really, only a _stable_ api is worth to be considered an API. Think about it.
You got it.
In old economy terms to keep it corporations-compatible (and if I formulated it the other way around): Then there is no in-kernel API. There are the syscalls you should use.
Have fun ....
Bernd
Signature · 3 lines
Firmix Software GmbH http://www.firmix.at/
mobil: +43 664 4416156 fax: +43 1 7890849-55
Embedded Linux Development and Services