This book was written as part of the first Devuan documentation sprint in December 2016. This is a reflection on software freedom and how to make an inclusive free software distribution that fosters simplicity, complexity, (meta)stability, and diversity. This is also an invitation for anyone with an interest in free software to chime in and participate in the Devuan project, their way.
Copyleft: This is a free work, you can copy, distribute, and modify it under the terms of the Free Art License.
The original book was written in English. You can find the original at https://bxl.dyne.org/actions/software-freedom-your-way.
Other (planned) languages: French, German, Spanish.
Code Is Politics
Not all software is born equal. Software brings forth unprecedented changes in our lives, as extensions of the human mind and capacity to act upon and shape reality. We must apply thought and attention to software development and we share responsibility, as users and developers of software systems, to foster values of cooperation in the spirit of science, human cultures, and the diversity of life.
Because of its grounding in human communities, free software enables a cooperative economy where collaborative research and public engineering of software are the norm. Sharing working programs not only allows users to satisfy their needs, it also generates a virtuous circle where more people can learn by themselves and with the help of others how to create appropriate technologies, for the benefit of a cooperative and inclusive society that respects both freedom and life. This is an exercise in respect and humility, in acceptance of diversity, and certainly a belief that cooperation will prevail over defection.
Therefore, code is politics and embeds power and potentials for change in the public sphere.
Four Fundamental Freedoms
A program is considered free when it upholds the 4 freedoms: to use the software as you wish ; to study the program and how it works (perusing its source code) ; to these individual freedoms, two other freedoms come into play at a collective level : the freedom to distribute exact copies of the program, so you can help your neighbor ; and the freedom to modify the source code and distribute these modified versions under the same conditions.
“Free software” means software that respects users’ freedom and community.
Nevertheless, a program released under a free software license does not necessarily respect users’ freedom and community: this program may exercise a privative power, for example, when it becomes mandatory and exclusive to other programs that perform a similar but not identical function. (Richard M. Stallman characterized a proprietary program as an instrument of unjust power. (Wired, 2013-09-28))
Devuan emerged from such a situation where increasingly, a single program would strip away existing functionality to absorb it into a unique framework that intends to solve long-lasting issues. It may well be so in some cases, but asserting one superior solution over others often marks a denial of complexity. Others before tried to tackle the problems of
init, the first program to run on a Unix-like system, in charge of managing the life-cycle of other programs. But no free software before tried so hard to impose their own world view on everyone else. It is to preserve diversity and autonomy, and a certain vision of simplicity in computing that Devuan was born out of the Debian crisis.
The engagement towards diversity matches a desire to diverge from a technological path leading to monopolistic structures, would they be proprietary or open-source. Indeed, as technological processes are affecting every aspect of our lives, we observe that power structures occupy strategic points of control, crystallize, and propagate in the system beyond their original intent. This is an emblematic process of technological evolution that Devuan chose to step out from.
Instead, the Devuan Project stands to “do one thing, and do it well”, and strives for a minimalist, simple, and stable base operating system that follows the steps of Unix principles and the GNU philosophy. This position clearly leaves room available for all forms of particular integrations, and maximizes the diversity of possible appropriations, that translates already into a lively collection of derivative distributions. The distributive process can bring constructive interference from many human organizations that can set the path to form a public infrastructure.
The complete structure of the processes in Devuan development echoes this statement for simplicity, stability, and diversity. In all processes from documentation to development to distribution, Devuan fosters a circular, iterative, integrative process welcoming participation. Devuan proposes a Universal Base OS (“DUB”) that is fed by a Continuous Integration process stemming from all package creation happening on the development platform (“git.do”). The complete process aims to favor an easy access to making custom distribution via
devuan-sdk, the Simple Distro Kit.
The Devuan Project is a solidarity network of people who have made a common cause to create a free operating system aiming to provide a welcoming and convivial environment to develop shared infrastructure to facilitate and embrace a diversity of approaches adapted to each user’s community.
In this book we won’t come back on the controversy that presided to the schism in the Debian community, and led to the creation of Devuan. Instead, we’ll describe what we think makes the Devuan Project a sane approach to free software development that truly respects users’ freedom and community, and call for engagement in the larger free software project to transform society towards cooperation, inclusiveness, and variety. Devuan as a community-based free software OS carries in its development many of the issues associated to the situation set forth in this introduction, be they ideological, social, or technical: we will develop them in the following pages.
In biology, diversity is considered a primary source of life and a necessary condition for evolution. To Devuan, diversity is a premise that refers to technological and human organization. The project commits to encourage appropriation that can serve a multiplicity of goals. We are confident that people organizing with and around Devuan will produce a variety of situations, key to the formation of a lively network.
The Devuan Project embraces an inclusive and peaceful space for contributors and users. It works to improve the relationships with both upstream developers and downstream distributions, individuals and organizations: as a base OS for others to build upon, its model of organization promotes cooperation.
By starting small again, Devuan developers look at this project as a fresh new ground for a community of interested people and do not intend to frustrate any participant with hierarchy and bureaucracy beyond real cases of emergency. While engaging with the development of a free software is a personal commitment to a task, it is also a dedication to a collective process, hence something to be treated with respect: this is both a powerful and fragile position that needs to be supported.
Decisional processes are thus specific to each situation. Decisions are usually taken by action and affinity. Nobody can possibly follow each and every decision, so it is important that changes are thoroughly discussed, pondered, developed, and documented publicly using the mailing list and the development platform.
Relational processes are complex, they often bring together several situations that need to be understood. It has to be acknowledged how they each reflect socio-political structures fed by a history of relations leading to issues which need to be voiced. The Devuan Project environment leaves space for conversation towards challenging existing stratified power structures and invent new ways to co-exist in a techno-centric civilization.
Creating A Virtuous Circle
Technical documentation in manual pages focuses on explaining a program’s interface. When it comes to making programs work together, or solving issues that may arise in actual situations, documentation is often redundant, confusing, or lacking.
The Archlinux community made a special effort to provide a very effective complement to the package documentation shipped with the programs, in their wiki. Their pragmatic approach serves users beyond their own community, and we can only thank them and encourage them for that. But Archlinux is mainly a community of power users, who already know how Unix systems work and can figure out the missing bits by themselves.
With Devuan, a number of non-technical users started working with the documentation platform because they saw a fresh, welcoming space where they could participate without being rejected for their lack of technical knowledge — a situation too often seen across the Internet where questions deemed uninteresting are quickly dismissed with an RTFM, which reinforces a pattern where novices shy away, and technical merit prevails in a honor system inherited from paternalism (Mathieu O’Neil, Cyberchiefs: Autonomy and Authority in Online Tribes (Pluto Press, 2009)), further isolating developers from users. For the latter, free software communities are often difficult to approach, because they lack the proper language to address issues and are often regarded with condescension, especially as many developers have climbed this mountain from profane to expert the hard way, by reading complicated manuals, experimenting, and spending their nights on figuring out things by themselves. So they think everyone should go through the same pain in order to liberate themselves.
This derogatory attitude present in many technical circles stem from a myth of productive meritocracy that can be traced to the modernist views of the primacy of the individual over the collective that transpire in both the capitalist neo-liberal world view and the authoritarian socialist view of Stalin’s USSR. There, Stakhanov was considered a hero for ‘his’ super-human productivity (Russian miner Alexei Stakhanov was the instrument of a propaganda campaign to emulate workers, increase their productivity, and demonstrate the superiority of the socialist productive system.) ; in the West, the myths of the self-made man, who skyrockets to success ‘on his own’, or the lonely artist producing marvels ‘by herself’, or the ‘lonely genius’ scientist (often a white male) discovering new ways to understand reality, that promote such inadequate vision. Remembering Isaac Newton’s humble statement that he only sat on the shoulders of the giants who preceded him should clarify the inanity of this Alienation dream.
Obviously these examples pinpoint a lack of focus on the collective aspects of the 4 freedoms, that we’re insisting on here to demystify the cult of personality of the free software hero, working alone on their program to set the world free. This promethean mythology, that sets technical excellence and the associated reputation and honor system above the original project goal to set users free, ‘naturally’ generates exclusion on (perceived) grounds of demonstrated technical know-how, which contradicts the inclusiveness of the free software project. Being in charge — having control of your own life — is a core value of free software, and working collaboratively often means, for the people in charge, letting go of their power.
The approach set forth in the Devuan Project to reduce the scope of the project to a solid base, and to provide easy ways and the infrastructure for non-technical people to express their specific perspectives, appropriate the technical output without the usually required technical knowledge, helps bring together a rich diversity of participants. As both technicians and non-technicians are users of free software, making it possible for them to co-exist and collaborate is a critical feature for the future of liberating technologies.
A Conversation Cycle
Devuan encourages a participative approach where users can easily report issues to developers, and where developers can provide to each other’s code the attention required to ensure stability of the system and continuous improvement.
Conversation forms a core value in Devuan. Since we can’t possibly accommodate all perspectives, most processes in Devuan follow a simple circular pattern of conflict resolution: from conversation (“hubbub”) to discussion (“signal”) to implementation (“collaboration”) to publication (“solution”) and back. This circular pattern promotes participation and a historical perspective of development that fosters expression and acknowledgement of the diversity of perspectives, and the emergence of a common identity with respect to the project’s goals.
From the IRC and mailing list daily interaction, to issues on the development platform and the conversational flow in the documentation platform, we adjust our practices collaboratively, refining them towards sensible goals emerging from a better understanding of the complexities we’re dealing with as we go.
As the starting point of Devuan is a fork, once the primary objective of creating a sustainable infrastructure that promotes Init Freedom, the question of a positive identity arose. As development evolved towards the completion of this first milestone and the release of JESSIE, this pattern of conversational cycle emerged across all processes.
Let’s consider the Debian fork for a moment: it started with tensions over
PID 1, the init system ; the brouhaha of contradicting voices led to the Debian General Resolution that motivated a strong signal (the fork), and ensuing collaboration to create a working solution: the Devuan infrastructure. Once the solution was put in place, new tensions arose, provoking more discussion, e.g., about the identity of Devuan after JESSIE…
Obviously, collaboration on the fork that resulted in the release of Devuan JESSIE beta two years after the fork triggered a number of questions on how to maintain the cohesion of the community and make it more inclusive, how to talk about Devuan, how to position Devuan with regard to Debian, how to consider the governance of the project, and so on. Most of these questions are still pending, as the working solution focused on a simple objective (to provide continuity with Debian Wheezy, with a Debian Jessie-compatible release keeping
sysvinit as PID 1.) Yet, the traumatic event that gave birth to Devuan also reflected into the project’s infrastructure, as we’re going to see.
Governance issues were skipped until we have working code, and assumed by the forking party (“The VUA are in charge.”) ; it also set a future objective, which this book intends to frame, to create a “lighter governance” that would avoid the situation that led to the Debian fork. With this in mind, the focus on the project ‘naturally’ evolved to focus on simplicity, stability, and diversity and to reduce the scope of the project to redefine what a universal OS meant to us: the benevolent dictators in charge decided that Devuan would be a universal Base OS that takes care of including diversity of technical solutions in order to avoid entanglement and exclusion. This orientation led the infrastructure team to invent a new approach that delegates creation to derivative work, so that conflicting views on free software operating systems could co-exist in harmony, leaving space for innovation.
In terms of development, the conversational cycle pattern is quite easy:
- Hubbub: a problem arises (someone encounters a problem or an idea and shares it with the community)
- Signal: the problem is formulated as an issue on the development platform.
- Collaboration: the bug reporter and the developers cooperate to provide a working solution, using the issue notes and merge requests.
- Solution: working code fixing the issue is merged into the affected package and integrated into the distribution.
- Tensions: the shipped solution might provoke reactions if it affects other people, but hopefully, the working solution enables to focus on other issues that will arise.
Our documentation platform illustrates this pattern in more details.
The conversation begins on IRC or the mailing list, in the development platform issues, and among participants. It comes up as the result of a problematic interaction with packages, the platform, published contents on devuan.org, and the multitude of perspectives coming from each participant’s experience and reflection. Some ad-hoc responses can come immediately, revealing a simple solution or an existing resource. But most of the time, the conversation needs to turn into a more focused discussion.
Once a problem has been identified, it can evolve as a community topic (on the mailing list), a practical issue (on the development platform), or a documentation topic.
Our documentation platform, running the Discourse software, allows to easily turn conversation into discussion, merge and split posts, turn them into wikis where all participants can edit, to shape a solution together. We call it Devuan Discourse, because we’re elaborating a common discourse. For short, we call it ‘talk.do’ (for it runs at https://talk.devuan.org/), a intentional pun to maintain focus on collaborative action.
Once we’re happy with the result, we can directly turn the relevant wiki page on talk.do into a Web page that appears on our main site. The page itself provides a way to go back to discussion via integrated comments from the topic that served to create the page.
No result is perfect, and a chosen solution will certainly exhibit flaws leading to tensions, generating more hubbub, and eventually leading interested people into editing the page themselves with the help of others.
Because the editing process is mostly open (you have to contribute to gain privileges, so you can demonstrate your dedication, in the same way it works with code) and the publication process is separate (reserved to the Devuan Editors team), controversial changes need to be discussed and won’t affect the ‘official’ documentation available on the Web. This is unlike wikis, where you can edit right away, but still enables a low barrier of entry to contributors. Also, it takes more time than wikis, so that the larger community can participate in the discussion via other more public channels, like IRC and the mailing list.
Individual & Collective Freedom
(some parts of this section are adapted from “Reconciliation”, in Cost of Freedom, https://book.costoffreedom.cc/)
Free Software is run by individuals and groups. All actions are situated ; with regard to development, action taken on a personal project has consequences on the surroundings of the actor.
In the Western world, the promise of personal growth and individual freedom is considered the key to a successful life and/or entrepreneurship. In this context, however, individual freedom is often understood as the capacity to do anything you like without responsibility. In free software, stability is grounded on free, voluntary association, and a new concept of freedom is necessary to keep the system from running out of control. We must acknowledge that with freedom comes responsibility.
The pathway to a different socio-political organization starts with the deconstruction of the fundamentals of our civilization: individual freedom is most interesting in all aspects when it is measured with regard to the social constraints, it then becomes productive of worthy social and collective outcomes. Each individual can then root their personal development both in a local and global community, therefore reflecting personal action to nurture both the personal and the collective. Interdependence enabling self-determination can activate personal freedom as a responsible asset.
Free software development, taken as local production, remains inherently inscribed within the global community. While Devuan aims to provide a universal base OS, its main specificity is to host and maintain a diversity of projects while composing a larger infrastructure. Neither top-down nor bottom-up, it scales up transversally, in a distributed, scale-free, topless infrastructure. This process differs from bottom-up processes essentially because it self-organizes at all levels and acknowledges back and forth at each scale: by focusing on the core features of the OS and its distribution infrastructure, the Devuan Project enables downstream actors to appropriate the project and contribute interesting features back to the base OS.
Free software is an indication that the developers care about the well-being of their users. But it does not guarantee the quality of the code. Code quality comes from experience, attention, refinements, and collaborative code reviews. Public access to source code and a lively community help ensure the code is performing according to specifications and does not unintentionally cause havoc.
An example of this transversal feedforth comes from the excellent process implemented in Refracta: originally a Debian Lenny derivative, Refracta switched to Devuan when the project started; Refracta offers a unique approach that allows a user to customize the system and save it to an installation medium for further installation and customization. This simple and powerful concept allows one to appropriate the system easily, a feature that is responding to the caring philosophy of Devuan. Refracta’s approach made it easy for more derivative work to happen, without requiring the usual level of technical knowledge involved in the creation and maintenance of a software distribution.
Devuan’s Simple Distro Kit
Although the initial objective of the Debian fork was simple, what came out of it is not your usual free software distribution. It’s certainly focused on providing working code, yet it does so in ways that differ from others.
Consider, for example, how the Devuan Project occupies the namespace on its own development platform: all Devuan-related development groups belong to the
devuan-security, and so on. All Devuan groups follow this pattern, except for one:
sdk. Devuan’s Simple Distro Kit has a scope beyond Devuan, that can be useful to more distributions than just Devuan-based. Here lies the secret sauce of Devuan: instead of making “a distro”, the Devuan Project builds a solid infrastructure for other distros to flourish.
Devuan’s SDK is a minimalist framework to create a free software package distribution and generate installer images for various architectures, live media, and virtual machine images. The SDK automates most of the work required to roll out a fully-featured GNU/Linux distribution, and is a central asset in Devuan’s strategy to empower downstream distributors and users.
The SDK is a set of minimalist commands and libraries written in Zshell, designed to be used interactively from a terminal, as well as from shell scripts. It provides a Zshell environment using the
[zuper](https://github.com/dyne/zuper.git) programming library. It is released under the terms of the GNU General Public License.
libdevuansdk comprises scripts, helpers, and configurations common to all the SDK family of programs.
cli-sdk provides an interactive environment to interact with the SDK from a terminal running Zshell. It can be used from a clone of the git repository, by running
source load to load the environment.
arm-sdk provides an OS development toolkit for various ARM devices. Supported devices include: BananaPi, BananaPi Pro, BeagleBone Black, ACER ARM Chromebook, Veyron ARM Chromebook (RK3288), Cubieboard 2, CubieTruck, Nokia N900 (This emerged from a collaboration with the Maemo community to support the Neo900 free hardware smartphone project), ODROID-XU, OUYA gaming console, Raspberry Pi 0 (armel), 1, 2, 3 (32 and 64bits). First conceived as a component of Devuan’s SDK, it now aims to support multiple GNU/Linux distributions.
devuan-sdk-blends is a repository of configuration files that define in a very simple way the blend (the specific distribution) including its package list, scripts to create an
initramfs, copy specific files, and run commands on the chroot before it gets packed into a bootable image.
live-sdk aims at creating bootable Live CD images. It utilizes upstream
syslinux from kernel.org.
vm-sdk: the Virtual Machine SDK provides an example wrapper around
libdevuansdk to generate a QCOW2 64bit Devuan image for use with
Amprolla is an APT repository realtime merging mirror with caching support, used in Devuan to create and maintain package repositories. It brings package repository overlays to Apt-based distributions, a concept originating from Gentoo and present in other package managers such as GNU Guix. It was introduced as a quick way to solve the problem of serving Devuan-specific packages while keeping original Debian packages that don’t need modifications, in order to reduce both resource consumption and the necessary work to make the Devuan Project a reality. Amprolla is tightly integrated with Devuan’s infrastructure but may be used (and contributed to!) by others.
Amprolla runs as a daemon that monitors package changes in Debian by pulling them from Debian incoming repository queue, from packages.debian.org and sources.debian.org API. Once a change is identified, filters are applied to ensure the package dependency tree is correct. Then each modified package is synchronized to Devuan repositories. Amprolla maintains a complete local copy of all the repositories it tracks, but uses an HTTP redirect trick to save bandwidth and take advantage of the wide Debian repository mirror network for speed.
The local repository cache is used in case any new package in a Debian repository breaks dependencies or need actual human attention to be patched or built before insertion into the Devuan repositories. In any case, Amprolla can fallback to a previous version of the package if needed.
Amprolla integrates tightly with the development platform. It uses a SQL database to facilitate working at package level instead of suite level, and providing a REST API to access repository and package information and statistics. Version 2 of Amprolla will also replace
dak functionality of Debian.
Because it provides package repository overlays, Amprolla can serve as the basis to expand such overlays to implement, e.g., personal package archives, thus making it easier to fork packages in the distribution. As a result, Devuan users are empowered, and Devuan maintainers encouraged to collaborate with (and listen to) users.
When meeting around a self-determined project such as Devuan, the community decides to organize itself in a zone that could be different from existing social systems, where hope and dreams can sustain original activity and joyful, supportive reciprocity. People reciprocally engage each other in a set of decentralized nodes, and make many other independent choices that accumulate and lead the formation of autonomous structures. Such social aggregates that develop over time have internal rules that sometimes supersede larger social contracts (local ties, usual employment or customer relations for example). This relation in some way brings into play the fragility of its participants who get attached to the group by strong social ties, and come to depend on it. In this system, community validation is often the only validation for one’s commitment, and attention should be paid to personal engagement. Failing to do so may affect one’s ability to thrive within the group, in their professional or private life ; over the wire, nobody knows if you’re a dog, a kid, or a lonely person, and the implicit rule of equality among peers that may bring talent forward, may also silence distress. In all cases the work done should be acknowledged and valorized, as volunteering is a
fragile position. The authors believe “volunteer” has a distinct meaning than “free labor” and time and talent spent on the projects should be rewarded accordingly. Devuan is made of humans, and we intend them to stay alive!
Universal vs. Free
The Devuan Project recognizes a practical contradiction between the goals of software freedom stated by the GNU project and the goal of providing a universal operating system. Although ideally equivalent, the current state of commercial technology often does not leave much choice to the users with the constraints that the hardware they use impose on them.
The insistence of some hardware vendors to use restricted components (e.g., WiFi and graphics cards that requires proprietary firmware to be useful) and apparatus (e.g., DRM and restricted boot), and the rise of smartphones, tablet computers, and low-cost chromebooks running restricted open-source OSes that prevent users from controlling their machines are antinomic to software freedom and the idea of general
Nevertheless, the ideals of software freedom should not stigmatize users and when there’s no free equivalent to a required firmware to run a component in a user’s computer, she shouldn’t bear the burden of the industry. Tolerance is key to integration and caring.
It seems more important to contain the propagation of proprietary software instead, and inviting users to use and participate in free software from their current position beats lecturing them every time. Other strategies include : working with hardware vendors, and with public institutions to make them understand the superiority of free technologies to build an infrastructure of the commons.
An avenue to explore towards this goal is to recognize that public funding of privative technologies is a problem, and public funding of free technologies is the solution. What can free software do, that non-free software cannot achieve?
A Distinct Technology
This text is adapted from hellekin, Good bye “open source”, hello “free software”.
Computing technologies are a central component of our civilization. We must ensure that these technologies can better society, and not work against its members.
Production of computing technologies in the public space means a better understanding of its outcome, an easier learning curve for users and developers, and an abundance of shared knowledge that can be tapped to innovate freedom-, privacy-, and life-respecting technologies.
The asymmetry of power between those who control software production and the rest of humanity amplifies inequalities and fails to deter abuse. A free society needs free software. Like science, free software relies on peer-review to test its quality and pertinence, and does not impose blind trust on its users, like non-free software does. Because proprietary software users simply cannot know what the code is doing, they’re predisposed victims to abuse. Free software raises a first shield against pervasive surveillance, and marks a necessary step to protect privacy.
(Pervasive monitoring is an attack, according to post-Snowden RFC 7258, and more attacks have been discovered since (RFC 7624). Pervasive surveillance enable proprietary software vendors and criminals to spy on their users without their consent and capture private information, or execute arbitrary commands with
According to Gilbert Simondon’s Theory of Individuation, the means of production of an arbitrary technique are deeply rooted into the resulting technology ; any open-ended technology can evolve in unexpected, and unintended ways ; quality comes by successive iterations ; a complex network of simple elements is more fit than any static construction (made for a particular purpose) ; etc. All of this sounds like free software: from the Unix philosophy to “write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface”, to the distributed and iterative development model, free software is a good candidate for being a distinct technology from non-free software.
Between proprietary and free software lies not a technical difference, but a technological difference. The “four freedoms” make free software essentially public; and as the software evolves, a copyleft free software license tries to guarantee that it will remain free. That makes copylefted free software particularly well-suited for developing a public infrastructure: its development is driven by the needs of the user, and its strong Copyright policy makes it available to the public, once and for all.
Free software’s reliance on community also provides a foundation for cooperation in its development: businesses and institutions can share their developments and make the software evolve in ways that are simply not possible with non-free software. In contrast, usually, the normalization of non-free software support makes it difficult or impossible to adapt to specific needs of the user.
Technology is not only made of machines, it is also composed of humans who are organized in different social structures, from close binding relationships, to larger networks, each of them with its own history and relational model. They all are affected by their epoch and surroundings, as much as they affect them, they contribute to form our society, both via their production and their choice of organization.
It is from a multipoint perspective that the observation of the actual complexity needs to be undertaken. Here, the existence of independent organizations is essential as they bring specific perspectives and strong nodes for human interaction to take place. As human presence on earth is scaling up hugely and with the growth of social control apparatus, the examination of relational complexity is critical.
Humans organize and regulate their relations (by a constitution for example), but as communities develop, it is very difficult to foresee the larger scope of the implications of a given regulatory system, mainly because one cannot envision properly the incidence of the context’s evolution. Indeed it has been acknowledged that no relational setup is neutral:
Just like public spheres, networks are not neutral communication spaces or level playing fields. Preferential attachment does not explain why certain actors experience more success than others in fostering connections and accumulating resources (Mathieu O’Neil, ibid.).
Contributing to software freedom means to care.
Thus, communication is essential to acknowledge transformation in the relations and to approach specific needs (e.g., see the important conversation about “Maintainerless Debian?” in LWN, December 2016). In order to build a free software infrastructure, the Devuan Project favors constructive conversation and respect over bureaucratic regulation.
Our Gitlab instance serves to report issues, program and package, and facilitate interaction between participants, keeping the processes fluid and consistent.
To participate in Devuan development you need to register an account on our development platform at https://git.devuan.org/. This account will give you access to private repositories for your projects, and allow you to fork existing projects there. It also grants you single-sign-on access to talk.do, the documentation platform.
Git makes forking repositories easy and recommended, so anyone can propose changes. So, when in doubt: fork!
git.do includes an issue tracker. Each group has its own, therefore you need to know where to check for and report issues: this is documented at https://devuan.org/os/issues.
Devuan-specific packages, either forked from Debian, upstream, or original works, belong to the
devuan-packages group. If the issue is related to a package in this group, then you can use the issue tracker for the corresponding package project:
If the issue is related to a package distributed with Devuan but not in the
devuan-packages group, that means it comes from another source. You can then fallback to the Devuan Project group, and tag your issue with
Package, so that Devuan developers know how to handle the case: pass it on upstream, and sometimes fork the package into Devuan to accelerate the correction or to avoid entanglement.
After JESSIE is released, we’re planning to add
debbugs integration with Gitlab so that fellow debianists can feel at home and use the well-known interface to report issues.
As a member of the platform, you can easily fork a package to your private space and work there to provide solutions and send merge requests back to the current package maintainers without further ado.
You’re also free to start your own development there, if it’s intended to improve Devuan and has a proper free software license: if your project doesn’t target the ‘main’ archive, you’re welcome to look somewhere else. Developing on the platform is not necessary to contribute to Devuan but will make it easier to integrate with our workflow.
Devuan packages benefit from automated Continuous Integration with Jenkins. Devuan maintainers can trigger automated builds by opening build issues with specific tags for target architectures and suites, and receive build logs to ensure their changes work as expected. This works towards easing package maintenance, improving quality, and aims at encouraging reproducible builds.
Roll Your Own Distro!
The Devuan Project welcomes derivative work on its platform. If you intend to work on a Devuan blend, starting there means you will benefit from our development, CI, and distribution infrastructure. This promotes unity in diversity.
How Devuan Releases Work
Like Debian, Devuan uses codenames to identify different releases other than numeric versioning, and like Debian, Devuan has a release cycle involving different suites.
The 3 main suites in Devuan are, exactly like in Debian:
unstable. The fourth standard suite,
experimental, is reserved for testing new packages, or packages that aren’t yet
Any new package will, maybe after a period in
experimental, go to
unstable. After 10 days have passed without major issues following the introduction of the package in
unstable, it will be moved to
Like in Debian, Devuan
stable follows a “when it’s ready” release cycle.
Following the Debian tradition of aliasing codenames to release names, Devuan will alias
testing to their respective release names. The
unstable codename also has a fixed alias: Ceres.
For compatibility with Debian, Devuan
unstable codename is aliased to sid as well as its release name Ceres. Ceres was the first minor planet ever discovered, and announces the pattern chosen for Devuan release names: after Devuan “JESSIE” 1.0, named after Debian’s release 8.0 for compatibility, each Devuan release will be named after a minor planet, using the first letter of the name in alphabetical order. For testing ASCII was chosen, as it has meaning in the IT world and it’s a minor planet name as well.
After Devuan JESSIE becomes
old-stable, and ASCII becomes the
stable release, a new names starting with B will be chosen from the Minor Planet Center Names List.
A dwarf planet is round and orbits the sun, but is unable to clear
its orbital path such that there are no similar objects at roughly
the same distance from the sun.
– NASA Dawn Mission Press Kit
Ceres was the first recorded discovery of a minor planet, on January 1st, 1801, by Giuseppe Piazzi, from the Observatory of Palermo. It is a dwarf planet, and the largest member of the asteroid belt. Soon after his discovery, Piazzi wrote: “I have announced this star as a comet, but since it is not accompanied by any nebulosity and, further, since its movement is so slow and rather uniform, it has occurred to me several times that it might be something better than a comet. But I have been careful not to advance this supposition to the public.” He lost Ceres in the glare of the Sun after one month of tracking, but could not find it again because of the lack of proper method to predict its orbit. The young Carl Friedrich Gauss, at the time 24, solved this problem in a few months, inventing a new method for preliminary orbit determination still in use today.
Occasionally Devuan wants to organize a conference to gather developers and keep the Devuan community in touch. Face-to-face meetings are not only productive, they also nurture the community.
Devuan user conferences are organized locally to bring awareness about Devuan to the regional community, with install parties, conferences, workshops, etc. A local Devuan group, registered on talk.do, can reach to the fundraising community and access local sponsors on behalf of the project.
Devuan doesn’t do “hackathons”, perceived as too competitive. Instead we do “code rafting”, which can be understood as cooperative hackathons, setup to solve specific problems that require the attention of a number of developers. They function like documentation sprints (and may be combined with one), but for source code and materials. A rafting can be organized to release an infrastructure program, define a user interface to reuse across desktop packages, create a new or finish an existing program, teach upstream developers to maintain their own Devuan package (without adding too much burden to their workflow), etc. A Devuan rafting produces free software (generally: GPL.)
A documentation sprint gathers people together to complete an important documentation task in very little time. It’s an intense workshop where the objective is to substantially improve an aspect of the Devuan documentation. Between 6 and 12 people live together for a few days and create quality documentation. How-to guides and official documentation can be edited and refined to reach printable state. The product of a docsprint is improved documentation online, and possibly, in print for sale to benefit the Devuan Project.
We would love to gather all people who participated in Devuan since the beginning to a 1.0.0 release party. Our current perspective, given the dispersion of Devuan developers around the world is to make it a remote event. Sometimes we dream about a real, face-to-face gathering to put flesh around the IRC nicknames. This means thousands of Euro in travel costs, a significant CO2 release in the atmosphere, expenses for a venue and all the costs associated with gathering a number of people at the same place. Way out of our budget.
Sponsor a Devuan Gathering
For all these events, we’re looking for sponsors to help us reach that goal, partners who are promoting free software, responsible and sustainable businesses and who share our vision for a free, inclusive society. If you’re a company who’s relying on Devuan, please consider hiring a Devuan Developer to keep working on the project. A dedicated developer is more valuable to the project than a struggling one, and working a part-time or a full-time job on Devuan is a great gift to your company. Devuan developers are all around the world. Make your proposal on talk.do “Job Offers” or the mailing list. Can you help?
Please let us know!
Diversity in Devuan engages people and their projects as commensals (from latin: “eating at the same table”) over the same resources. Commensality is a mode of co-existence, a way of sharing and optimizing resources that functions thanks to a dynamic relational network, in a specific ecosystem.
Forming relations in Devuan happens via human interaction and binding affinities among groups that originate a large variety of projects. Devuan intends to welcome new voices and newcomers, who can easily
take part and appropriate the resources for different and unexpected purposes.
This commensality opens the path towards sharing possibilities that can actually co-exist, a possibility that we can envision because it matches a specific situation, a com-possibility. Com-possibility is a way to freely compose with reality.
Devuan’s heart resides in its different human organization, that promotes the quality of our endeavors, and its public value, a process that needs to be supported as such. When integrating the idea of the public good and the commons we can envision to develop the fundamentals of free software.
Devuan is com-posing freedom, your way.
This book was written on Devuan JESSIE, using GNU Emacs, Markdown, \LaTeX, and pandoc, as part of the first Devuan docsprint organized in Brussels, Cologne, Antwerp, and online by Dyne:β×λ, from December 7 to 13, 012016 HE.
software freedom, your way is © Dyne:β×λ
Copyleft: This is a free work, you can copy, distribute, and modify it under the terms of the Free Art License.
Printed in Brussels by Gillis on recycled paper.
Follow the source: https://bxl.dyne.org/moments/three
Page 9: wave fronts triggered by falling raindrops interfering on pond
surface, by quapan (CC-BY 2.0)
Page 26: Constructive Interference, by Scott Robinson (CC-BY 2.0)
Page 57: Ceres. Courtesy of NASA/JPL-Caltech/UCLA/MPS/DLR/IDA.