Bodymind Operating Systems

How to apply the best practices from software development back into our lives?

Let's start with a metaphor: what is the operating system you run as a human being? Is it open source? Is it resilient? Stable? Are you updating it often enough? What kind of apps does it run? How does it affect your hardware — your body? And — most importantly — why does it run at all?

// TODO: answer the existential questions

If you work in software development you know that this field has some of the best practices. However, when it comes to ourselves we often don't even realize that we can transfer some of those practices back into our own lives.

We need to adopt the hacking mentality in relation to ourselves.

The main problem is that a lot of the stuff we "run" as the human beings are based on ancient concepts and outdated evolutionary circuits. Education, culture, religion, old habits, new fads...
Too often, we don't even look into the code. We just run the software given to us, taking it at face value.

Some of it is proprietary, much of it is quite old (yoga, religions, the old morals and beliefs), a lot of it has vulnerabilities and trojan horses (hidden agendas). We don't fork, we don't iterate, we don't review the code, we don't use APIs and we don't perform tests. This has to be changed.

Just like there are different operating systems for the different devices, there can also be operating systems for the human beings.

During the past decades we have given technology a lot of our energy, resources and time. We did get something in return: mainly more convenience and efficiency for our lives. Comfort is great, however, the true value of what we've collectively developed is in the methods and practices that we use.

Let's forget about AI and Singularity for a moment — they will take care of themselves. Why not take care of ourselves and adopt some of the best practices that we've learned into our own lives.

What if we rewrite the operating system that runs in our bodymind, making it open source, agile, resilient, and compatible?

Example #1: Open Source and Version Control

Open source is a good way to start. When you're open source you are open to external influences, you can inspire and get inspired, you can let people rewrite your own code and rewrite theirs. Open a pull request, resolve merge conflicts, here comes the next version.

See something that can be made better? Fork it. Need to test something out? Make a new branch, you can always revert back to the master. Big update in your life? Branch by abstraction is a way to do it and there are many other approaches...

Going full open source on yourself has profound ethical implications, probably more than any religion and the best thing about it is that it's not religious at all. It's just practical and also fun.

// git push origin master

Example #2: Modular Programming vs Vulnerability

We have a tendency to take things very seriously. Something bad happens and it affects us completely. The whole day is messed up, the whole body hurts.

Let's think of ourselves as modules and learn to compartmentalize the dependencies. A problem in one part does not mean that there should be a problem in another.

Sure, we have to attend to the problem and fix it. Compartmentalizing is not about putting our head in the sand, rather, it's about giving us an opportunity to stay functional even when some parts are broken, so we can attend to them, understand the vulnerability, and then fix it.

// var errorhandler = require('errorhandler')

Example 3: Resilience

Good code is resilient. It can take any input and take care of it. Resilience doesn't work through tension, although it seems like the most obvious choice sometimes. A very bad hosting provider has one blocked all traffic from a single country to fight off DDOS attacks on my server... We don't need firewalls like that.

We need clever heuristic algorithms that can take in an input, analyze it properly, and then respond. A truly resilient application is the one that is malleable, so it can stay open, and yet does not lose its form and has a capacity to respond.

// socket.on('login', function(data) {})

There are many more examples of the practices we can use and I would be curious to hear your feedback and suggestions on this. However, one important question remains:

How do we actually make sure all this stuff actually works and does not remain in the abstract realm of philosophical exercise?

The Body is the Answer

Too often we've neglected the body. I'm not talking about the sedentary lifestyle and the endless pizza rounds. I'm also not talking the daily cross-fit session or wearable devices that have a "positive impact on our efficiency".

We need to stop treating ourselves as human resources, let's leave this to HR. We need to treat our body as a precious piece of hardware, one of the best tools we have to inscribe the imaginary into the real.

A scientifically proven fact: when we practice something, we physically change ourselves. If you read the studies of neuroplasticity you will see that every action you do repeatedly engraves the new channels in your brain and nervous system.

And it works much better if you do it with your body. If you stop doing the action, the new channels will gradually fade away. Your body is the most advanced memory stick you will ever find.

The brain and body have to work together. Merely thinking of something does not help. That's why physical practice and rituals are intrinsic to most comprehensive systems of knowledge.

So if we want to go open-source, if we want to write modular code for our bodymind, if we want to really understand resilience, we need to experience it through the body.

A good example are the studies on meditation. We can talk about equanimity and non-attachment all we want (// think of a good analogy from software development), but it has been shown that continuous meditation actually transforms you to become the very thing that you practice.

Your brain changes, your rhythm changes, your behavior changes. You start to act differently. Thinking about equanimity does not help.

Practicing it with the body, having a continuous embodied experience is what makes it work.

How do We Do That? Practicing the New EightOS.

One of the many possible implementations of this idea is to develop a physical practice, which would incorporate the methodologies used in software development into physical movement patterns.

Talking about resilience? Let's try to experience what it is like to be resilient through the body. Forking and branching? Let's try it in a group of people and copy, transform, and "commit" each others' behaviors.

In order to test this approach we developed EightOS bodymind operating system. The main idea was to take the best practices from the world of software as well as the behaviors observed in complex metastable systems and to apply them on the level of the body.

The objective is to develop an operating system for the bodymind, which can be used for different purposes: to be more resilient, to open up to external influences without compromising security, to know how to modulate tension, to be creative using numerous APIs that help us connect with other practices.

The physical aspect is what makes it possible to record these new patterns of behavior on the level of reflexes, so they become immediately available on the subconscious level, bypassing the crucial milliseconds it takes for the conscious mind to realize that it has to act.

Our proposition is one of the many possibilities. You can try it out yourself and treat it like an app: if you like it, you keep it, if you don't — you can fork it or erase it from your system completely.

Our main intention is to propose a different way of practicing being yourself. An open ethos with no ultimate solutions: always updating, always reiterating, writing your own code, building your own hardware.

// hacker eightos

PS if you would like to contribute to our open source project, see our source code on GitHub or check the website www.8os.io for concrete applications.