<?xml version="1.0" encoding="UTF-8"?>

<!--

	Sane Software Manifesto

	Copyright © 2019 František Kučera (Frantovo.cz, GlobalCode.info)

	This manifesto is licensed under a Creative Commons Attribution-NoDerivatives 4.0 International License.

    https://creativecommons.org/licenses/by-nd/4.0/

	If distributed, official website of Sane Software Manifesto must be provided: https://sane-software.globalcode.info/

-->

<manifesto

	xmlns="tag:globalcode.info,2019:sane-software/manifesto"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

	xsi:schemaLocation="tag:globalcode.info,2019:sane-software/manifesto ssm.xsd">

	<title>Sane Software Manifesto</title>

	<id>fd466b50-6abd-4294-b11f-a5b8f2f39c2a</id>

	<preamble>In respect to user freedoms, privacy, liberty and software quality we create software according to the following guidelines.</preamble>

	<chapter>

		<name>Free software</name>

		<id>ca4d0f6c-9996-49ac-8647-b7f15b049b03</id>

		<item>

			<id>a755410b-6264-4094-b339-aeca55448e8d</id>

			<text>Every piece of Sane software is also Free software (as originally defined by Richard Stallman).</text>

			<text>Which means that the user has freedom to</text>

			<text>run the program for any purpose, </text>

			<text>to study and change it (i.e. has access to the source code under a free software license) </text>

			<text>and to distribute modified or unmodified copies.</text>

			<note>see https://www.gnu.org/philosophy/free-sw.html</note>

			<note>see https://www.gnu.org/philosophy/who-does-that-server-really-serve.html</note>

		</item>

		<item>

			<id>b7cd1a50-79eb-4df2-925c-7243a46d5ed8</id>

			<text>The user controls his computer and software and owns the data. Not the author of the software or anyone else without user's explicit consent.</text>

		</item>

		<item>

			<id>c78a9796-7862-4dd2-8ad9-3fdae094fe2c</id>

			<text>Must be buildable using free software toolchain (like GNU/Linux + GCC or OpenJDK etc.).</text>

		</item>

		<item>

			<id>b3c0daaf-dcaf-49a8-ae38-40590456a315</id>

			<text>Must not promote non-free (proprietary) software or services.</text>

		</item>

		<item>

			<id>b2fd5d2d-4d47-48e8-8abc-4b1aa94a7951</id>

			<text>Copyleft licenses (like GNU GPL or GNU Affero GPL) are strongly recommended because they guarantee software freedoms to every single end-user and prevent possibility that freedom vanishes somewhere in the distribution chain and the user can not benefit from the free software albeit the software is build on originally free source code.</text>

		</item>

		<item>

			<id>c3599313-338b-428d-885f-964a443d76c6</id>

			<!-- TODO: MUST + exception for older software -->

		</item>

		<item>

			<id>f39b90ae-0054-467e-a9e2-43379b7c2331</id>

			<text>If the software is distributed with a hardware, the hardware must support instalation of independently built software without any restrictions or requirements (e.g. digital signature from the original author).</text>

		</item>

	</chapter>

	<chapter>

		<name>Documented</name>

		<id>e1c828c5-0a4f-4948-9943-db1ae16a42d5</id>

		<item>

			<id>c63ea2ac-c255-4f3e-a0e2-b49d1e145347</id>

			<text>At least basic documentation must be released under a free license (GNU FDL is recommended).</text>

		</item>

		<item>

			<id>fd8e3bbd-d46a-40fe-85a6-b902336456d4</id>

			<text>Every advertised feature must be properly documented. Undocumented features can not be considered as features from the user/customer point-of-view.</text>

		</item>

		<item>

			<id>e4dede5b-059e-4e47-b03d-80142b8467f1</id>

			<text>There might be also other documentation/books released under any license and price.</text>

		</item>

		<item>

			<id>c0df4d14-43f8-4b61-83c4-fb5896161aeb</id>

			<text>But average software engineer must be able to build and operate the software with just the free (basic) documentation.</text>

		</item>

		<item>

			<id>e6cd9c52-0e66-402c-930c-901fa66acd22</id>

			<text>There must be a free documentation with description of building and running the software on a fresh operating system installation including description of all dependencies.</text>

		</item>

		<!--

		<item><id></id><text>documentation should focus on all target groups: users, administrators, developers</text></item>

		<item><id></id><text>there must be a big picture and software architercure described</text></item>

		-->

	</chapter>

	<chapter>

		<name>Semantic versioning</name>

		<id>aa8bd952-842b-4391-aefe-d9b3750e432d</id>

		<item>

			<id>a8beddfc-11e3-4012-9f88-f79dc88eee16</id>

			<text>Semantic versioning is required.</text>

			<text>The version number consists of three numbers: major.minor.pach.</text>

			<text>Major version is incremented if there is an incompatible change.</text>

			<text>Minor version is incremented if a feature is added in a compatible way.</text>

			<text>Patch version is incremented if a bug is fixed in a compatible way.</text>

			<note>see http://semver.org/</note>

			<note>If authors are unable to distinguish between compatible and incompatible changes, they must always increment the major version. However this approach is not recommeded</note>

			<note>Propper Semantic versioning is especially important if the software is suposed to be used as dependency by others.</note>

			<note>If there is a need of some marketing or cool versioning/codenames like Ultrasonic Umbrella or 2016, they should be used in addition to semantic versioning, not instead of it.</note>

		</item>

		<item>

			<id>cf557a11-b307-4c2f-a7b5-5d2485d23258</id>

			<text>Once publicly released, the package must not be changed anymore – if a change (even a small fix) is needed, new version number must be assigned.</text>

		</item>

		<item>

			<id>dd013325-bf22-43d3-9579-0e272e2ac344</id>

			<text>APIs, file formats and protocols might (and usually should) be semanticly versioned independently from the implementation.</text>

			<note>In such case, there should be a table documenting which API/format/protocol version matches which implementation version.</note>

		</item>

		<item>

			<id>dacb98cc-b558-4f0e-942d-e12004e45606</id>

			<text>The branching model in the version control system should reflect the semantic versioning.</text>

			<text>The released version e.g. 2.3.1 should be tagged as v2.3.1 and be placed in the v_2.3 branch.</text>

			<text>Where the v_2.3 branch was forked from the v_2 branch – from the v2.3 tag.</text>

		</item>

	</chapter>

	<chapter>

		<!-- TODO: rename this chapter? this is also compatibility „with others“ Or merge with previous one-->

		<name>Compatible with itself</name>

		<id>d626bb57-a20a-4182-a88a-446e901e9de4</id>

		<item>

			<id>a9852300-c59a-4bda-86a1-3a90d2ee1b74</id>

			<text>Focus on backward compatibility. Newer version should work as a drop-in replacement.</text>

		</item>

		<item>

			<id>f9b07d6c-da34-4971-8a92-a50b3e9f80ff</id>

			<text>Do not break things – rather postpone the release date than deliver a faulty product.</text>

		</item>

		<item>

			<id>ae33d206-4988-44ec-b8e2-3120019fcf2f</id>

			<text>Do not remove features unless they are really obsolete, unused or unrepairably broken.</text>

		</item>

		<item>

			<id>c542336a-fce8-412c-a8dd-1328c1a884ec</id>

			<text>The user interface might be simplified or redesigned while preserving the features under the hood.</text>

		</item>

		<item>

			<id>ba8fecf0-5c02-4fdf-abdc-2650d428f82a</id>

			<text>Incompatible changes must be planned and announced in advance. <!--Major/minor/patch numbers must be increased according to the Semantic versioning.--></text>

		</item>

		<item>

			<id>f4826891-e732-45e8-b929-25d1182fa141</id>

			<text>Upgrade scripts and upgrade documentation must be provided.</text>

		</item>

	</chapter>

	<chapter>

		<!-- TODO: rename this chapter to Interfaces? -->

		<name>Compatible with others</name>

		<id>d34ce339-197c-44ee-9e5c-6d7e212f8c10</id>

		<item>

			<id>be4c72d1-c494-4c44-aeb4-c5847f5a3524</id>

			<text>use open standards (protocols, formats) if they exist</text>

		</item>

		<item>

			<id>b2202690-8a6c-467f-a2b1-b154f470aa77</id>

			<text>never extend nor modify existing open protocol/format in the way which effectively creates a proprietary protocol/format</text>

		</item>

		<item>

			<id>dd206223-9525-4229-be2b-84b07c2b8244</id>

			<text>define and publish own open standards if needed</text>

			<item>

				<id>f24d45b0-a07c-45d8-820e-63a3b95ba3f6</id>

				<text>also standards must be semantically versioned</text>

			</item>

			<item>

				<id>d341b78e-15b9-4077-8b48-9e54c93391ac</id>

				<text>should be written in machine readable format (WSDL, WADL, ASN.1, XSD, Diameter dictionary, D-Bus etc.) or at least formal language (Backus–Naur Form, EBNF etc.)</text>

			</item>

			<item>

				<id>d61b3e31-bb9f-4333-87c8-9fb32f33a49d</id>

				<text>also configuration should have machine readable description and should be testable by executing a command</text>

			</item>

		</item>

	</chapter>

	<chapter>

		<name>Modular architecture</name>

		<id>c56e7e86-e480-4a5d-8a47-ab155dcd59b1</id>

		<item>

			<id>e50424e8-94f3-48aa-bf01-0ba984eb2349</id>

			<text>larger and multi-purpose software should be divided into smaller modules</text>

		</item>

		<item>

			<id>e752efae-75c9-4620-aa14-65c4949a3609</id>

			<text>modules must have defined dependencies (less = better)</text>

		</item>

		<item>

			<id>e9988ed0-d686-41a0-9f1e-3243ac5235d5</id>

			<text>particular modules should be compilable and executable separately</text>

		</item>

		<item>

			<id>ac722cec-0734-4d80-9885-d70a97b6402b</id>

			<text>whole system should be compilable (buildable) with only selected modules – must not require compilation or even distribution of all modules, if they are not necessary</text>

		</item>

	</chapter>

	<chapter>

		<name>Extensible</name>

		<id>d333af72-b5b5-432f-b564-a008d54a85d1</id>

		<item>

			<id>a7bc51ba-9832-4f75-983c-e75dc0801113</id>

			<text>able to be extended</text>

			<item>

				<id>e190f58d-1c16-4198-94d6-fc1a99fa85a0</id>

				<text>by configuration (RegExp, SQL, XSLT, XPath etc.)</text>

			</item>

			<item>

				<id>fde301e5-6e75-49a4-85c8-a231f6a63036</id>

				<text>by scripting (Guile, Bash, Python, Lua, ECMA Script etc.)</text>

			</item>

			<item>

				<id>a9c63cea-b9df-4bbd-bec1-84a047514667</id>

				<text>and/or third-party plugins/modules</text>

				<item>

					<id>de7270db-0410-4152-974f-4f0d74ff255b</id>

					<text>it should be easy to create a third-party module and plug it in an existing system</text>

				</item>

				<item>

					<id>fb4b07d1-6af7-44d9-8e6a-89ea63638652</id>

					<text>dependencies needed to write an extension (i.e. header files, API classes/interfaces) should be as small as possible (do not require large codebase to write a mere plug-in); the required dependency should contain just interfaces (method/function signatures) and data structures but no implementation (executable code)</text>

				</item>

			</item>

		</item>

		<item>

			<id>e41134a4-715c-4926-a7df-01ff3759eda1</id>

			<text>there should be public directory of extensions/scripts</text>

		</item>

	</chapter>

	<chapter>

		<name>Testable</name>

		<id>a0376231-d53e-45fd-826f-47148721de3d</id>

		<item>

			<id>d95dc118-7473-4f18-8b9e-35830a87b269</id>

			<text>there should be automated build-time complex tests for the package – feed the program with sample input and verify expected output</text>

		</item>

		<item>

			<id>a9f6725d-ddf1-41ee-96b4-15f3b851cb50</id>

			<text>there should be also automated runtime/postinstall tests – in order to verify that software was installed properly, all required dependencies are met and basic function is guaranteed – the program should report problem during its start (as a warning if it is not fatal), instead of unexpected failures during operation</text>

		</item>

		<item>

			<id>d610c04b-cc44-48c7-b069-f41b90bdef0f</id>

			<text>unit tests are recommended for code parts that are internally complex (algorithms, important business logic) and have simple interfaces</text>

		</item>

		<item>

			<id>e85baeda-8fcb-42d1-bb53-d7386a941ae7</id>

			<text>each external interface should contain procedure/function that does nothing important or heavy, is idempotent and returns simple response which proves that the interface (connection) is working (e.g. echo, print version, status or current time); if authentication and authorization mechanisms are present, there should be one procedure/function callable anonymously and one that requires authorization</text>

		</item>

	</chapter>

	<chapter>

		<name>Safe code and sustainability</name>

		<id>f3afbaf2-0933-43d2-aed0-8dc568b9429f</id>

		<item>

			<id>a96206c9-3e69-483d-b575-6bab9dec4a30</id>

			<text>correctness, safety and readability is prefered to performance</text>

		</item>

		<item>

			<id>d8eba0dd-4305-44b9-80ea-4c38b6dfa633</id>

			<text>use strong data typing, declare preconditions and possible exceptions</text>

		</item>

		<item>

			<id>ebea0c16-f820-444d-a73c-3054ca6a38c8</id>

			<text>data structures must be known and well documented – do not use undocumented map keys or properties</text>

		</item>

		<item>

			<id>e24e600e-6542-4664-8cf0-2d8c6feb6c13</id>

			<text>code, comments and specification should be written in the same natural language</text>

		</item>

		<item>

			<id>fa92aa33-a69f-43b8-9051-9bfdcd3d293f</id>

			<text>there should be a dictionary of used terms, so whole team and also users and customers will speak the same language</text>

		</item>

		<item>

			<id>b9345a0e-c672-45d3-b93b-8d0fb4ece8b3</id>

			<text>fail fast – errors in the code should be reported during build time or at least on first execution – do not silently continue if given error would lead to failure later in another part of the code – bad weak coupling leads to difficult debugging</text>

		</item>

	</chapter>

	<chapter>

		<name>Small code footprint</name>

		<id>ba8fbf3a-9254-4dd8-bb77-b0cd4907c6aa</id>

		<item>

			<id>f5389468-2f8a-43c8-884a-8df6bc844453</id>

			<text>less LOC (resp. cyclomatic complexity) = better</text>

		</item>

		<item>

			<id>b6b6c838-be6d-43d5-9f99-2098fa217c54</id>

			<text>reduce boilerplate and unused code</text>

		</item>

		<item>

			<id>b07fe0f0-2be7-4c1c-9b19-b671269c5e58</id>

			<text>use code generators (during build process, not to generate code to be manually edited and versioned)</text>

		</item>

	</chapter>

	<chapter>

		<name>Sane dependencies</name>

		<id>afd8f6c7-8dac-4a83-a101-64f017ec7ada</id>

		<item>

			<id>c2d5a677-a721-40e3-b560-73afe76fe2b0</id>

			<text>avoid NIH and reuse code but also avoid dependency hell</text>

		</item>

		<item>

			<id>d214987c-881c-450b-8544-82141866f541</id>

			<text>know your dependencies, know why they are required</text>

		</item>

		<item>

			<id>c8402612-e136-43b5-9209-f9800d2e94da</id>

			<text>reduce dependencies to only necessary ones</text>

		</item>

		<item>

			<id>cbeb9a6b-7b64-4452-8caf-246c082a853d</id>

			<text>depend on small and useful libraries – not on bulky application packages or libraries with large transitive dependencies</text>

		</item>

		<item>

			<id>cbaf55be-8ffb-4109-9c83-083d1b3e793a</id>

			<text>if dependency on bulky application package is inevitable, add a layer of abstraction – create a generic interface and connector and allow others to replace the bulky package with their own sane implementation</text>

		</item>

		<item>

			<id>d7655989-a5e4-4123-9147-3782fc05a5ee</id>

			<text>helper tools:</text>

			<item>

				<id>a5307bc9-36ed-4d83-963a-30c5c67613aa</id>

				<text>if you e.g. use Bash and Perl during the build process, do not add also Python dependency, write it in Perl – or use Python instead of Perl.</text>

			</item>

			<item>

				<id>b0237d84-7068-4b2b-bc28-ce5e0a0061e4</id>

				<text>Or if you use Java as your main language, consider not using Python/Perl for scripting and use Java for it</text>

			</item>

		</item>

		<item>

			<id>a0f42ec9-5032-4f6d-a50a-4b7bddde77f0</id>

			<text>if possible, always depend on abstract interfaces, not on particular implementations</text>

		</item>

		<item>

			<id>c5974dcd-4855-40c5-ad22-894c128ca1dc</id>

			<text>from the whole system point-of-view, Bootstrappable builds should be taken into account</text>

			<note>see http://bootstrappable.org/</note>

		</item>

	</chapter>

	<chapter>

		<name>Easily auditable</name>

		<id>fb0c484b-d97a-4cb4-9b8f-04d386ef0f54</id>

		<item>

			<id>aeef6a5c-bafc-4fcf-9b21-5829e8a44c5e</id>

			<text>small code footprint and minimal dependencies makes it easy to do security audit</text>

		</item>

		<item>

			<id>ab69d352-da68-40c2-a3e1-a8fd5c41ad0a</id>

			<text>avoid ungrounded refactoring and reformatting – they make mess and noise in the version control system and impede the audit</text>

		</item>

		<item>

			<id>e4db77b8-f145-4e43-bf8b-eb775b9352c8</id>

			<text>refactoring/reformatting changesets should be separated from substantive changes</text>

		</item>

	</chapter>

	<chapter>

		<name>Reproducible builds</name>

		<id>da6436f7-c352-4d52-915b-02d0d1880e40</id>

		<item>

			<id>e5154815-eeae-4664-8883-a29a64eea325</id>

			<text>builds should be reproducible: same code/version → same binary package</text>

		</item>

		<item>

			<id>a3b0c164-4dde-4e33-b3be-5478d2a187e2</id>

			<text>if not, it should be documented, why and how build products mihgt differ, and there should be plan/task to make it reproducible</text>

		</item>

	</chapter>

	<chapter>

		<name>Trustworthy packages and sources</name>

		<id>e7ded437-aaa2-475a-9754-0b2d89394b24</id>

		<item>

			<id>a0d9322c-7d2b-4632-b543-7e0d75bb5f0b</id>

			<text>every released version (binary or source) must be cryptographically signed by the authors (GnuPG/OpenPGP is strongly recommended)</text>

		</item>

		<item>

			<id>feb97ec0-c35c-49b8-b455-517a929b4a84</id>

			<text>there should be also checksums/hashes for every released package</text>

		</item>

		<item>

			<id>ff33e209-0460-4a43-997f-d6b32b73997b</id>

			<text>if HTTP is supported, HTTPS should also be – the attacker/eavesdropper should not even know what software/package/update is downloaded by the user</text>

		</item>

		<item>

			<id>c1f83b3a-e564-4483-91de-9c08723efd13</id>

			<text>the attacker should not be able to suppress updates – the program must not be silent in such case and must warn the user that something possibly nasty and dangerous is happening </text>

		</item>

		<item>

			<id>c6a755c9-a54e-4ffb-8f70-bfbd851b93c5</id>

			<text>releases should be downloadable also (or exclusively) over BitTorrent or other P2P network</text>

		</item>

		<item>

			<id>f9275c3c-2b09-4aec-ac28-76ff827d52ce</id>

			<text>source code repository must be accessible through an encrypted connection</text>

		</item>

	</chapter>

	<chapter>

		<name>Network interactions</name>

		<id>d3edb71b-8668-4290-a669-19694956e3aa</id>

		<item>

			<id>c967092e-09e9-4c68-90bf-aa8cb441f7dc</id>

			<text>no network connection is needed during build – build must be possible completely offline, all dependencies must be downloadable and documented including secure hashes or better cryptographic signatures</text>

		</item>

		<item>

			<id>b5515d33-1531-4361-8baf-a99ca461e763</id>

			<text>if dependencies are optionally automatically downloaded during/before build, the packaging system must cryptographically verify that that they are undamaged</text>

		</item>

		<item>

			<id>f700413a-fde1-460c-8633-76985e98007c</id>

			<text>avoid unwanted network interactions during runtime – no „call home“ or update-checks without user's explicit consent</text>

		</item>

		<item>

			<id>f55c2ebd-c3ba-44f7-ae92-06f679780ec7</id>

			<text>if any network connection is used, it must be cryptographically secured against MITM attacks</text>

		</item>

	</chapter>

	<chapter>

		<name>Localized/internationalized</name>

		<id>fa655b7c-f22d-4b98-ab7b-c0d0f608aad8</id>

		<item>

			<id>ad2f572b-497b-4523-b435-f9752fd1518a</id>

			<text>is is strongly recommended that it should be possible to localize the user interface independently from the original author by writing a language pack</text>

		</item>

		<item>

			<id>c3827486-6bf5-45c0-9a6d-61ad659d8ba1</id>

			<text>GNU Gettext or other standard framework (like Java resource bundles) should be used</text>

		</item>

		<item>

			<id>a57f4fc8-1f64-46e2-a91d-3a598c37f2e9</id>

			<text>error messages should have assigned unique error codes, so it is possible to find relevant information regardless current locale</text>

		</item>

		<!-- GEC is recommended for such unique error identifiers -->

		<item>

			<id>eba92867-5c1b-45b6-943a-a3fa6ea67e38</id>

			<text>data formats and protocols must be language/locale independent</text>

			<item>

				<id>fee73fee-4940-47ac-84b6-15646f5f61c7</id>

				<text>e.g. use decimal point instead of comma and no thousand separators for numbers, use standardized date formats</text>

			</item>

			<item>

				<id>f1a00487-ed89-4443-99b5-63ab4c635690</id>

				<text>in general: everything that is expected to be machine-readable or machine-generated must be independent from current locale</text>

			</item>

		</item>

		<item>

			<id>e6603e06-0b2c-439e-82ce-45f9744b2ef8</id>

			<text>character encoding:</text>

			<item>

				<id>abd42a7f-bd4b-4034-98ee-85a33094b5c1</id>

				<text>always be aware of it, do not just blindly use current platform's default (because the other side might run on different platform with different default)</text>

			</item>

			<item>

				<id>abd48eae-d287-4729-80ee-52dd018b0ba7</id>

				<text>if given software/format/protocol has some default encoding, it must be clearly defined in its specification and this default should not be changed without changing the major version number</text>

			</item>

			<item>

				<id>c9f4d9f4-f959-48ad-bc68-6720dd4596e3</id>

				<text>if there is no default, the encoding must be specified in the metadata attached (e.g. protocol headers, extended attributes on filesystem) to the actual data or at least at the begining of the data (like declaration in XML format)</text>