Standard interfaces

[Angelo Schneider]

Hi all,

OOHPS.....

See below.

Alex Nicolaou wrote:
> 
> John Cowan wrote:
> 
> > Is Java code that binds such standard interfaces inherently unfree?
> 
> Yes, standard interfaces of any kind, and the software that implements
> them, are inherently unfree.
> 

What, if not a standard interface, is the glibc?
If you improve glibc you will certainly keep the calling conventions
and the parameter types of the standard c functions, wouldn't you?

> I think this is clear if you browse the philosophy pages at
> http://www.gnu.org/ but I could not find an appropriate quote. (A lot of
> the language about the freedom to "change" software uses loaded
> language, like "The freedom to improve the program"
> (http://www.gnu.org/philosophy/free-sw.html. It seems to me that
> "improve" is a synonym for "change". The intent is unclear; it may be to
> cast all changes to software in an inherently good light, or perhaps to
> express the FSF's disapproval of patches that introduce bugs or virii
> into programs. One could certainly have a lot of interesting discussion
> about whether being able to change a standard interface is actually an
> improvement or not.)
> 
> One of the things that used to frustrate me the most about GNU software
> is how it deviates from standards; gcc accepts a superset of C, g++
> accepts a language that it almost but not quite a superset of C++, and
> so on. The GNU philosophy has always been to improve what needs
> improving and see if the improvements catch on. This is a source of
> recurring debate on several open-source mailing lists that I follow.
> "Should we do this the standard way or the better way?" Interestingly,
> many of these debates go in the direction of the standard simply to gain
> more acceptance and use of the software whether it is a good direction
> or not ... but the debate implies the freedom to deviate. The rule for
> acceptance appears to be not the definition of the formal standard, but
> the practical question about whether the software can achieve a de facto
> standard which is so similar to the formal standard that it can be
> called by the same name and consumed by the same individuals. This
> produces software that is sufficiently close to the formal standard that
> people are inclined to ignore the differences and the underlying issues
> altogether.
> 

Linux and the GNU Project would not exist if they would not agreee on 
somewhat fixed standards. You can extend the interfaces and standards
by adding more interfaces or by making changes which keep compatibility,
but you certanly can't change the arguments to fprintf() or fopen()
or popen() or what ever without getting into a lot of trouble!

> The fact that some people have sympathy for the de facto approach
> towards standards can be seen in the support for Microsoft in the
> Sun-Microsoft suit over Microsoft's implementation of the JVM: the
> statement of many is that the "market should decide" and there is
> support for the idea of simply seeing which standard survives as the
> definition method of choice.

The market follows always short term considerations e.g. the price.
But technology is not pricy when it is brought to market. Only hughe
companies can effort to develop a new technology and place it for free
or nearly free on the market. (MS vs. Netscape!) 
Standards which are build upon market decisions are not as valuable like
those which are build up from industry consortiums (e.g OMG, POSIX).

This does not mean that all consortium standards are well enough defined
:-)

The market has no vision "where to go to morrow", industy has or should
have, 
at least.

> 
> alex

Angelo

---------------------------------------------------------------------
Angelo Schneider           OOAD/UML           Angelo.Schneider at xcc.de
Putlitzstr. 24         Patterns/FrameWorks       Fon: +49 721 9812465
76137 Karlsruhe             C++/JAVA             Fax: +49 721 9812467