Open Standards



One of my recent questions over at yahoo answers was to find out if the C language is actually something proprietary. If it is proprietary then the whole line of Linux operating systems would be something developed from a proprietary compilers. But then I found out it is not exactly proprietary. Actually someone there had given an answer that it is a standard - an open standard.



At first I wondered what is an open standard? And if compilers/operating systems are built to support an open standard what does that imply? I slowly figured out the answers to these questions; and that is why I am composing this post. And finally I was able to conclude one thing about linux: it is theoretically unhackable.



The exact definition of the term open standard is rather of a debate. It may connote a wide range of meanings. One of those meanings/implications could mean 'things that must be definitely incorporated'. (So in a sense it is an attempt towards universalization of those things). Although this idea is rather abstract, it explains a lot of things to me:



Take the example of a common/popular standard - ANSI. The American National Standards Institute. And take a popular implementation of that standard - ANSI C compiler. The C language is a very versatile langugage in one sense. You can develop just about anything - even an entire OS; but at the cost of frustruation. However developers still use it. Because no other language equals its versatility. You can also couple assmebly routine to normal code. We usually do this to optmize a particular section of code; so that on a whole the application might work faster.



The ANSI standard can be used in conjunction with developing C-like compilers. (That is probably what ANSI C usually implies). It means that whatever is mentioned in the standard the complier has to implement, provided it abides by the standard in full respect. This would otherwise mean that it must have a standard set of library routines or functions. And that means any function that is mentioned in the standard should be present and it should do what is dictated in the standard. In other words, a function that is standardized has a particular requirement; abstractedly it would mean it should do this and only this. But how you do that is entirely at your discretion. You get to decide how it is implemented. The only rule is that it must be implemented.



This is where a developer of a compiler says perhaps I could develop this function, this way. A lot of people develop compilers in such a way that it supports the standard, and in addition to that they develop their own libraries. Sometimes these libraries may not abide the standard, however he or she does it so that their requirement is also met. The proper sense here is not misusing, but people can misuse it. And that is where the pitfall is, especially when we think of proprietary compliers.



In proprietary compilers everything, every implementation is hidden. Meaning you'd have to execute a function to find out if it works fine, i.e. the way it is expected to. But to be absolutely sure we need the source itself. Otherwise we cannot really know. Sometimes the function can do more than it is asked to. But that part might be something malicious for your computer. The thing is you never know.



But there are free compilers that allow you to do this kind of thing, i.e. validate the source code; see-for-yourself-if-it-works! It is the result of such products that operating systems such as linux have become what it is today. I guess most of the linux kernel is developed using the GNU C compiler that is licensed under the GPL. The GPL (or the GNU Public License) mandates that everything should be free to scrutiny and modification. Hence the kernel came out as a result of this. A whole community worked on that kernel nad made it what it is today. And people still work on it!