Revision of specification freedom from Fri, 10/24/2014 - 03:31
The revisions let you track differences between multiple versions of a post.
Specifications
A specification is a description of a save format or communication protocol. This description --a document-- can be free or proprietary. If free, anyone may read the document, implement the specification, and use the format/protocol.
Specifications exist for two reasons:
1. Save formats Specifications can describe a way to save information. We call these “formats” or “save formats”. We use save formats to store our music, videos, and text.
2. Communication protocols Specifications can also describe how to communicate over the Internet. We call these “communication protocols”. The “xmpp” protocol is free; it helps people communicate by instant message, voice, and video.
Specifications and software freedom
Specifications
What is a free specification?
Free specifications support software freedom. Free specifications ensure that people can use free software – to open saved work, communicate, and play media.
A specification is free if the person responsible for it gives everyone certain freedoms. She has to let anyone read the specification document, use the specification, and implement the specification. These freedoms ensure that everyone can use the specification with free software.
Software is free if anyone may audit, modify, distribute, and use it. These freedoms let us control software on our computers, individually and collectively.
The alternative is to give third parties control: a specification is proprietary if the person responsible for the it withholds the specificaion-freedoms.
People responsible for proprietary specificaions usually withhold specification-freedoms to lock users into a monopoly relationship. Users' saved work (if saved as a proprietary specification) will open with one –usually proprietary– program.
Why do we need each freedom? In many countries, civil liberties advocates have won and implemented some measure of individual autonomy and freedom. The specification and software freedoms apply those kinds of aspirations and values to people who use computers. We need each specification and software freedom to control software that runs on our computers.
a) Why do we need each specification-freedom?
The specification-freedoms ensure that people can choose to use a save-format or communication-protocol with free software.
The freedom to write programs to run the specification ensures that we may use the specification with free software.
Specifications as free documentation support this goal, because programmers need to understand the format to support it.
And we need the freedom to use the specification, to realize the software-freedoms.
b) Why do we need each software-freedom?
The freedom to audit free softwares' instructions gives people meaningful insight into what the software does. With proprietary software, we know what it does only superficially. For example, proprietary software with surveillance features may not put those features on display for users. And because proprietary software disallows meaningful audit, users may never know.
The freedom to modify free software allows people to correct malicious features. It also allows people to adapt the software to their needs, or improve it generally.
The freedom to share free software ensures that your friend can be free, even if he could not otherwise afford it.
The freedom to distribute free software with modifications lets the whole user community benefit from improvements -- and not just programmers individually.
The freedom to use free software ensures that we can benefit from these software-freedoms.
Proprietary specificaiton
A proprietary specification undermines this possibility. Proprietary specifications restrict people from sharing the specification document. And restrict the specification's implementation.
Proprietary specifications steer us to proprietary software
In two ways... a) Social pressure Proprietary formats are social pressure to use proprietary software. If we share information with others in a proprietary format, we encourage them to use the one compatible proprietary program. The more information our community stores in the proprietary format, the more difficult it is for any one member of the community to break his dependence. b) Third-party control The person responsible for the proprietary software withholds software-freedoms. He makes decisions about instrucions that run on our computers, without transparency. He may choose whether to take information from us, and whether to let us know that he does. If software unnecessarily collects users' information, and offers the software freedoms, anyone may identify the offending instructions, correct those instructions, and distribute the modified software. Proprietary software does not offer the software freedoms. If proprietary software unnecessarily collects users' information, the user community might never find out. If the community learns of the issue, they can at best accept the responsible party's word, that they do not collect the information anymore. Since proprietary software does not offer instruction-transparency, we cannot distinguish safe proprietary software from the unsafe.
Free implementation of a proprietary specification
Free implementation
Free software (like LibreOffice) can save to apparently-proprietary formats (like .doc). When free software offers this option, it's because the developers reverse-engineered the proprietary format (eg .doc). So if you use LibreOffice to save your work as .doc – that particular .doc is a free format. Even though the official .doc is proprietary.
If your friend uses proprietary software (like Microsoft Office) to create a proprietary format (like .docx), that save file is proprietary. He may email you the file, and you may be able to open it with free software (like LibreOffice). If you can open his proprietary file with free software, it's because the free-software developers reverse-engineered the format. The format is still proprietary.
Consequence
Why does format freedom matter [if free software developers can reverse engineer proprietary formats, to work with free software]? If we use proprietary formats, and share our work in proprietary formats, we put pressure on free software developers to play “catch-up” with proprietary developers. The proprietary developers can change their specifications, and free-software developers must then work on reverse-engineering the changes.
It gives proprietary software developers some indirect control over free software developers' resources.
Specification vs standard: jxself post
Free implementation of proprietary specification: Magic Bananna and Legimet
contributors: antiesnob, muhammed
