Revision of specification freedom from Sat, 02/19/2022 - 17:00
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 neutral or narrow. If neutral, anyone can read the document, implement the specification, and use the format/protocol. A restricted specification is one or more of these freedoms.
Two types of specifications are relevant here:
1. Save formats
Specifications can describe a way to save information. We call these “formats” or “save formats”. We use save formats to store music, presentations, illustrations and more. 2. Communication protocols
Specifications can also describe how to communicate over the Internet. We call these “communication protocols”. The “xmpp” protocol is free; it lets people communicate by instant message, voice, and video.
Specifications and software freedom
Specifications
What is a neutral specification?
Neutral specifications accommodate software freedom. Neutral specifications ensure that people can use free software – to open and edit saved work, to audio/video call others, and to play media. The alternative is to give third parties control over our access to our respective saved work, and control over our respective communications with others.
People who are responsible for restricted specifications usually withhold specification-freedoms to lock users into a monopoly relationship. Users' saved work (if saved as a restricted specification) will open with one –usually proprietary– program.
Why do we need each freedom?
a) Why do we need each specification-freedom?
The specification freedoms ensure that people can use save formats and communication protocols with free software. Specification neutrality does not mandate free software. It merely allows the possibility.
- 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.
Restricted specifications steer us to proprietary software
In two ways... a) Social pressure: Restricted formats are social pressure to use proprietary software. If we share information with others in a restricted format, we encourage them to use the one compatible proprietary program. The more information our community stores in the restricted 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 instructions 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 (FIPS)
FIPS: save
Free software (like LibreOffice) can save to apparently-restricted 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 restricted.
FIPS: open
If your friend uses proprietary software (like Microsoft Office) to create work that is saved in a restricted format (like .doc), his save file is restricted. He may email you the file, and you may be able to open it with free software (like LibreOffice). If you can open his restricted file with free software, it's because the free-software developers reverse-engineered the format. Perhaps the free-software developers were entirely successful in their reverse engineering, or perhaps they were only successful in some aspects. The format is still restricted.
FIPS: Consequence
Why does format-freedom matter, if free software developers can just reverse engineer proprietary formats?
If we use FIPS and restricted formats --and share our work in those formats-- we put pressure on free software developers to play “catch-up” with proprietary software developers. The proprietary developers can change their specifications at any time. 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.
Of course, restricted formats and FIPS pressure people to use proprietary software. And that's not safe either.
Document Liberation http://www.documentliberation.org/
Specification vs standard: jxself post
Free implementation of proprietary specification: Magic Bananna and Legimet
contributors: antiesnob, muhammed
