Hello! 

I feel like what has happened is really a disaster, I don't feel like
contributing to GNU Guix anymore in the future. I think that the GNU
Guix maintainers justify unacceptable behavior and have acted upon
things without understanding them, not understanding why incidents have
happened, and at the same time that I don't feel that I can explain, and
that many people have spread misinformation that other believed also. 

I don't feel like there's any way forward to this, we really do not
understand each other, I don't know how to communicate the culture in
some feminist/queer squats in France around Paris where I live, where we
really feel together on the same page when it comes to these questions
and where also we exclude people who don't understand these goals, in
which I feel so good and where really every confrontation is avoided and
has many values that building an inclusive community like GNU Guix wants
to be. 

I think that the technicality of software development must be redefined
so that the hierarchy between the experienced and the beginner
disappears, I think that to cast as a beginner or an experienced is an
attitude, many people who are experienced cast themselves as beginners
for various reasons and that some other people cast themselves as
experienced for various other reasons. I think the difference between
the beginner and the experienced is a construction, I think that such
must be worked on so that every individual contributor can feel
independent and empowered and also not have to define themselves towards
the experienced. I think that the technicality of software development
implies a special kind of relationship with knowledge and experience, I
think that also must be re-invented, and in other social environments
like the feminist/queer squats I live in knowledge and experience is a
really sensitive topic and people who have knowledge and experience are
not always welcome to say what they know or what they think unsolicited
and if they are solicited, there's also a way to say that to never imply
a domination of student-professor, that to accept that someone does not
want to hear about supposed knowledge and experience, and also needs and
wants to feel proud and independent about what they are doing without
the help of people with said knowledge or experience. I think that in a
sense, everyone must become a beginner. I think it approaches a very
fundemental topic of software development especially in Free Software
communities that is to among others end meritocracy. I think that the
world of Free Software and Open Source is tainted by that meritocratic
spirit and that if we want to bootstrap inclusive communities we must
embrace that underrepresented people also are of very varrying skill
levels and that we must empower and include everyone no matter their
skill level, and that this notion even of skill level disappears and
that all people of varrying skill levels are also not interested in
feeling submitted to a pre-existing group of people with knowledge or
experience. That we must find other ways, tools, to organize tolerance
for mistakes, collectively, that errors become not problematic at all,
or that the possibility for error is removed, to create systems that
detect errors and only accept non-errorneous input, so that as long as
the contribution is a valid input from anyone, it is a valid
contribution, that there's no room for doubting, for having failed to,
for being responsible, for being accountable, for being blamed, if the
tool fails to detect errors then we are collectively responsible for
improving the tool, not individually responsible for triggering a
validation bug. The tool also must be friendly with the way it rejects
input, it must be helpful, it must provide guidance, it must not leave
anyone no matter who they are, no matter what they know, in a situation
where they have no idea what to do to create a valid contribution. I
think that inclusive tools remove the possibility for error. I think
that good UI/UX is when you can't go wrong, and that if you do, it's
easy to undo what you just done, always. I think that GNU Guix is many
situations many things can go wrong and I think that's not inclusive, it
pushes off many people because it induces important amounts of stress to
realize things can be wrong and especially when you can't undo them. I
think that somehow the tolerance for mistakes or errors from anyone must
be absolute, so that it is never an issue they happen. I think that for
example with the design of the web where HTML parsers are tolerant to
errors, that with JavaScript there's nothing that can possibly go wrong
with code you write, ideally nothing can possibly be a security issue
(not the case with JavaScript on the web but I think that if we were
given a chance to give another go we could fix it), I think that such
error-tolerant design is one of the reasons that there's also so many
JavaScript developers of very diverse skill levels, that to me it feels
very inclusive. I think that there's ideas to take from there. I think
also when we talk about practical software freedom, that we still have
systems that can only be controlled by programmers, that the majority of
people on earth are still bound to use tools they cannot control
themselves. I think that to reach true practical software freedom
everyone must be a "programmer", that controlling your system fully
becomes so intuitive, so accessible, so inclusive also, because I think
those topics are inevitably linked, that the need for "expert
programmers" disappears. I think that software design is strongly
entangled with the need for expertise and I think that for computing in
general to become ethical as a whole the difference between a user and a
developer, the words even, must disappear, become out of use, stop
making sense. 

Léo