Indigenous wisdom as a model for software design and development
Let’s say I am building a website for my best friend’s very small cat rescue. I build out a great website for her and her team of three to use, which helps them in their work to rescue cats, care for them and adopt them to caring friends. In building my friend’s website, I may employ dependencies - other pieces of software that my site depends on to work properly. These could be libraries, frameworks or other code that my site requires. When I put this code on a public repository like Github for others to use, they will know that they may need to install a certain CSS framework I use so it looks pretty for example. If they don’t include the right dependencies, the website may not look as cute, and may actually be broken, not be able to work at all.
There are also other dependencies that exist on a more abstract level. In addition to the software dependencies I explicitly list in my packages.json file, my friend’s cat rescue website also requires a browser to view it, it requires a network that uses http protocols, and it requires a computer, electricity etc.
Now that my website is ready for my friend to use for her cat rescue, she asks me if I could share this code with her friend far away who also has a cat rescue and would also love to use this same code for her website. They have the same needs, also have a small team and are using every penny for the care and wellbeing of the cats and cannot hire a software developer. I would love to share my code and so I put it up online and have it as an open source repository to fork it and use it.
Before I push my code online I make sure to include all the dependencies in my package.json file for any future developer to use when making the next iteration of the website. There is just one catch: I don’t want my code to be used by shelters that kill animals. But while I can effectively require developers to use certain software packages to run my code, there is no analogous way to require that my software be implemented in a way that is ethical and consistent with my values.
Wampum.codes is my first iteration of the project to develop a model of ethical software dependencies - an attempt to inscribe community values and developer accountability into code. The way it works is as follows: In my package.json I have a wampum.codes dependency which makes it clear that this project I created is free for them to use and they can use this and modify it in anyway they want besides close sourcing (open sourcing already covers this case). However I have also encoded my own values: I only want my code to be used by shelters that are “no-kill” shelters.
As you can see, it is formatted as a normal JSON file. I’ve borrowed a few terms from the domain of software development and repurposed them to help explain how an ethical dependency might be structured, and what kinds of information it might contain. The following is a brief explanation of how I use each term.
Where this project is going to live. Maybe it is not a page at all - it could be a remote repository or even a physical location - but for this example I’m using a website as an example.
It is common for software to have commands that initiate a series of other commands. These commands sometimes take arguments that allow developers to specify some of the initial conditions and configurations of the project.
In a Wampum.codes file this should be a clear articulation of your project’s purpose that answers the questions: What are you and your community trying to do? How is this contributing? What could break this contribution? After you’ve spent some time thinking about these questions, try to condense it down into a single summary or mission statement.
This is an opportunity to identify the non-negotiable limits of your values. How could this concept be broken? How could someone use this contrary to its purpose? In the case of our code for no-kill shelters, an obvious condition that would violate our values would be if it were used by a kill-shelter.
Linting is kind of like spell-check for code - it’s a script that runs through what you’ve written and catches errors. It is common for linters to offer up suggestions to resolve errors by trying to guess what the developer might have meant. By analogy, in Wampum.codes linting can be thought of as a stage for identifying some possible uses of your project that would be close enough to your intentions. This can make your ethical statement more robust and provide the community with context and precedent for evaluating potential future uses of your software.
In our cat shelter example: What if it’s a dog shelter? What if it’s a shelter for homeless teens? What other types of uses to which your project could be put, even in oblique ways, that would nonetheless be consistent with your original purpose?
When you are doing software development you need a command to actually generate the files you need to host the site on a remote server. For Wampum.codes the build stage is an opportunity to think about the real world implications of the project.
Up until this point we have been dealing in ethical abstractions, but now we turn our attention to practicalities. What are possible externalities, and how do they relate to our vision for how the project is to be used? What will this create in the world? What help can this bring to the community we are building this for? What are practical things this project needs in order to survive? Where do I see the result in 1 year, in 5 years and in 10 years? What is the death cycle? How long should this reasonably work for (it is ok if it is short lived)?
Create a one sentence summary which includes one practical thing this project needs to survive and one thing I hope it will leave as a legacy.
Code is also a part of a community, and open source - while vital and necessary - is still based in a legal framework enforceable by trademark and copyright rather than in community co-creation and consensus. Can ethical software dependencies be enforced in a similar way?
Consensus building and co-creation can have aspects of enforcement or, if you really need it, punishment. I can imagine it would be quite simple to figure to have notifications and auto takedowns for certain tokens, or API keys that you could revoke if someone uses your code in a way that violates the wampum.codes ethical requirements. But the immediate task at hand is to figure out first how to articulate the values and ethics we want into a project and go from there.
You can’t tell who is cheating in a game if you don’t first know the rules. I think we have space to begin to articulate our ethics and values and not have the conversation derailed before we get a chance to design a game because we don’t have the perfect way to catch a cheater. Let’s at least get some like minded people to sit down together and start to play.
Wampum.codes started out as a podcast. I wanted to bring like minded indigenous thought leaders together in order to talk about what inspires them and how they put their values into practice using technology in positive ways for their communities.
There is not a set of universal guiding principles for indigenous people. We are very diverse. However it is my desire to take the wisdom from this inspiring group of people and hopefully offer up a new framework for designing software ethically. If you like it great, if you can’t see why it is uniquely indigenous, I’m not sure it matters. Let’s make the world a better place, indigenous wisdom is about movement, love, time and responsibility.
So maybe try it out and see if it unlocks something that you care about. If it does, then I hope as part of the way you pay it forward you will remember to include indngenous people in all of the meaningful projects that you do.