FOSS as polyphonic, interrelational traces

This post is to collect some random thoughts and resources on open source vs. free software, a difference that is critical at this polyphonic time, which may become monologic, to borrow from Bakhtin. I’ve bold-faced thematic sections as an experiment with tl;dr.

Important literature that distinguishes free software from open source is Evgeny Morozov’s work in the Baffler and the work that first taught me the difference (not so long ago): the FSF’s Why open source misses the point. That said, the free software ethos continues to permeate work in open source – but whether it will continue to is up to us.

It seems that we are at a crossroads between continued polyphony and monologism. In the former, individuals can speak for themselves – and, arguably by extension, can contribute to society lest society be deprived of their contributions (c.f.). Polyphonic dialogue can be considered more objective and closer to reality because it acknowledges this complexity of other voices/narratives. I used to be content teaching such things to be students within a narrower confine of philology but we can all see that what the WEF calls a “great reset” is upon us, and this reset is largely shaped by advances shaping the latest human tool: that of digital technology. This tool, as will be seen below, is ever-increasingly mediating the world. At such times of change, we humanists know that every daily choice we make at critical junctures will quietly, almost untraceably, change the collective whole.

I am concerned with traces because this approach suits Ted Nelson’s (rather philological…) respect for maintaining the relations within networks and suits a Ricoeurean attempt to interpret traces without claiming to ‘speak for’: listening carefully, to be as accurate as possible. It also means making my own digital traces, no matter how rudimentary, which I have been able to do through free software which lets me make what I want so encourages me to learn more.

The “FOSS” space is interesting for so many reasons: its origins; how it is being used by proprietary contexts; the competing views within it – which are not always clearly interdefined.

For example, despite the clear distinction between open source and free software outlined above, I wonder: Are some open source devs/maintainers/contributors are effectively working with free software ethics? I started to think about this while listening to Henry Zhu’s excellent podcast Hope In Source, which also links back to his other podcast, Maintainers Anonymous. Speaking of Henry’s work, Babel itself is a testimony to polyphony: respecting different languages while making them relationally intelligible through backwards compatibility. [Speaking of backwards compatibility, I need to mention Emacs here and ask whether there is something philosophical about this programming ability, something philosophical, too, about Lisp and its dialects…]

What would happen if we lost the traces to the knowledge that allow for such interrelational knowledge? What would happen if the culture that promotes interrelational learning were to lose its appeal? In pedagogy, we speak of ‘mutism’, where students no longer think it worth it to even try, because they believe in advance that any effort is a lost endeavor (c.f. Freire).

This week’s EFF Episode 102 on how to fix the Internet is related to such concerns.

The EFF podcast102 presents open source as having free software roots – which need to be respected if open source is to fulfill its true promise:
The open source movement is growing, and that growth is creating pressures. Some stem from too many projects and not enough resources. Others arise because, as more people worldwide join in, they bring different dreams for open source. Balancing initial ideas and new ones can be a real challenge, but it can also be healthy for a growing movement.
All tech should be customizable by the people who use it. Because as soon as things are proprietary, you lose control over the world around you.
Open Tech Strategies’ James Vasile opens by saying:
And increasingly, everything in the world is touched by technology, which is to say that open source is everywhere.

Free software is at the heart of every device that people are buying on a daily basis, using on a daily basis, relying on. Whether they can see it or not, it’s there and our tech lives are just powered by free software collaboration, very broadly speaking. So, that’s pretty cool right?

And that’s amazing. So from that point of view, we’re doing really well.

Unfortunately, there are other aspects in which that growth has created some problems. We have lots and lots of free software projects that are under-resourced, that are not receiving the help that they need to succeed and be sustainable. And at the same time, we have a bunch of crucial infrastructure that depends on that software.

And that becomes a problem How do we sustain free software at this scale? How do we make it reliable as it grows and as the movement changes character? Adding people is such a big deal.

… free software as it exists based on these initial notions laid down by Richard Stallman, that’s a wing of the community that is very identifiable, but is not growing as fast as the free and open source software movement writ large. And one of the things that happens when you add people to a movement is you don’t always get the same people joining for the same reasons as initially the first people started it.

You add people who are joining in for reasons of practicality, you add people who are joining in just because peer production of software works.

This is a really good way to go about linking arms with other producers and making really cool stuff. So there’s some people who are just here for the cool stuff. And that’s okay too. And as we add more and more people, as we convince the next generation of free and open source software developers, I think we’re finding that people are getting further and further away from these initial ideals.

… we describe [these ideals] very broadly as the freedom to run the software, the freedom to modify the software, the freedom to distribute those modifications, the freedom to copy the software, the freedom to learn about the software. And that notion that you can open it up, look inside and learn about it. And that that is a thing you should be able to do by right and that you should be able to then share those things with everyone else in the community.

And that when you pass on that sharing, you are also passing on those rights is baked into some of the earliest licenses that this community has used. Like the licenses published by the Free Software Foundation, the GNU family of licenses had this ideal, this notion that not only do I have the right to look, the right to copy, the right to modify, the right to distribute, but that when I hand the software to the next person, they should get all of those rights as well.

So that’s what this community was founded upon. But very early on, from those initial free software ideals, we also had the rise of the open source wing of the movement, which was very much trying to make free software palatable to commercial interests and to expand the pool of contributors to this world. There was a weakening of the ideals where people decided that in order to appeal to new audiences, we needed licenses and we needed projects that use the licenses that we can do the passing on of rights.

So you can hand it to somebody but not give them all of those rights along with it. You could hand somebody a piece of software and while you yourself enjoyed the ability to study it, to copy it, to modify it, maybe you don’t give those rights to the next person that you hand the software to.

And that was the first big shift.

Listen to the podcast/read the transcript here. It is certainly complex. It describes software designed to be used only in certain contexts (how does that go with the first part of what is excerpted above?); sustainability without corporate investment and dev sustainability in general; Cindy Cohn and Danny O’Brien mention the unintended consequences of acts meant to be “good”; rethinking remuneration for value; software as a public good; the problem with ML-systems where there’s a lack of transparency – above all, thinking through what it means for the world to be “mediated by technology” as Vasile acknowledges, and the importance of protocols…

While there is a lot of responsibility on programmers of all kinds I want to stress that there is also responsibility on laypeople. I remain shocked at how educational institutions, for example, largely adopted just one form of proprietary software to deliver lectures when the pandemic hit – as opposed to holding an emergency debate over what the best approach would be. This is an example of terrible monologism – especially because it is terrible digital course design to rely solely on video conferences to deliver content. We have known for years that this is not the best way to make use of tech in classroom contexts. Personally, I use FOSS mixed media and make sure there are asynchronous options and explain the meaning of free software (I mean, we are selective about the pens and notepads we choose – why wouldn’t we draw attention to the tool, especially since most students do their homework using Internet searches, etc.? [This also further reiterates how digital course design needs to accommodate new habits, but there are plenty of ways in which to do this, e.g.])

It is on all of us to decide how it is that we are working with and using tech in 2021 as even the smallest decision has a cumulative effect. I agree with Ricoeur that while knowledge pulls away from ideology, “ideology always remains the grid, the code of interpretation, in virtue of which we are not unattached intellectuals but remain supported by what Hegel called ‘the ethical substance’” (1991: 269). Which ideology are we supporting through our software use/contributions and why?

Posted By: