Pain, The Protective Software

The way that pain works can be a tricky thing to conceptualize. 

And I think a big reason for this is because pain is not something that we can visualize or get our hands on. It’s not that it’s immaterial per se, but rather that it is the product of a lot of really complex microscopic activity and interactions happening within our Pain System. 

What we can visualize and get our hands on are things like muscles, bones, joints, nervous tissue, etc., which is why it can be easy to point to these things and say that they are the sole cause of pain. And though these tangible things are of course relevant, we know that pain is much more complex than that.

One way that I like to wrap my head around some of this complexity is to compare the human organism to a computer.

The human as a computer

A computer has a few key components:

Hardware: the physical components that you can touch, such as:

• The processor (CPU), the brain of the computer that executes instructions

• The motherboard, the main circuit board connecting all components

• The hard drive, the storage for files and software

Software: the programs and instructions that tell the hardware what to do, such as: 

• Operating systems (OS) such as Windows, macOS, etc., which manage hardware and software interactions

• Applications like web browsers, word processors, games, etc. 

• Firmware, a special type of software embedded in hardware components that provides low-level control for hardware components

So while the hardware is what you can touch, the software is what tells the hardware what to do.

Let’s think about this in terms of the human organism.

In the human organism, the hardware would be the tangible components of the body like muscles, bones, joints, organs, vascular tissue (arteries, veins, etc.), nervous tissue (spinal and peripheral nerves), etc. 

The software, on the other hand, is the programs and instructions that communicate with and control the hardware. This would include things like motor (movement) programs, feedback (learning) and feedforward (anticipatory) mechanisms, thoughts, emotions, memories, and pain.

Another key component

But there is another key component that is missing from our analogy here: Data.

Data is the bridge between the hardware and the software. Data is simply information, and that information is used by the computer and human organism alike to transmit messages between the hardware and software and to make decisions.

Importantly, while it is the hardware that collects the data, it is the software the interprets the data and uses it to make decisions and tell the hardware what to do.

An example

Let’s say you want to stand up and walk across the room right now. 

In order for that to happen, you must have the necessary hardware components (muscles, bones, moveable joints, nerves to transmit the messages from your brain to your muscles, and a brain and spinal cord to create and execute the instructions).

You must also have the necessary software components (the “walking” motor program, and the feedback and feedforward mechanisms to anticipate issues and make appropriate adjustments as you walk).

And of course, these innumerable interactions that give rise to the movement of walking across the room are all made possible by an incredible amount of data flow from the hardware to the software and from the software to the hardware in a continuous and circular manner.

Pain as Software

Where does pain fit into all of this? Let’s look at another example.

Let’s say that you touch a hot stovetop. When you do that, information (data) will be transmitted from your hand (hardware) to your central nervous system where multiple protective mechanisms (software programs) will be employed to protect your hand from being injured. This includes (but is not limited to):

• Motor programs that tell your body to move in a way that allows you to quickly pull your hand away from the hot stovetop

• Learning processes that make it less likely to happen again

• Thoughts

• Emotions

• Pain

The purpose of these software programs is to protect the hardware (the skin of your hand) and to prevent something like this from happening again in the future. 

This is very useful indeed! In fact, nearly all of us have had this experience at some point in our lives, managed to avoid serious injury, and have learned the dangers of touching hot stoves, all thanks to pain and our other protective software programs.

An Unwanted Software Update

After an event described above, it’s normal to have pain that lasts for a few days or weeks at most (depending on if there was an injury and the extent of the injury). 

But sometimes after an injury or event a software update happens. One that makes pain and the other protective software programs more sensitive. When this happens, pain can become protective beyond what’s necessary to keep the hardware (the body tissues) safe. 

This can look like several things, including:

• The pain spreading to include a larger area

• The pain occurring on the opposite side of the body in a mirror-like pattern

• The pain occurring in diffuse, changing/fluctuating, or unpredictable locations

• Things that normally are painful being more painful

• Things being painful that aren’t normally painful

• The pain coming and going without obvious causes

It can be helpful to remember that this unwanted software update is our body’s attempt to help by protecting more. Ironically, though, excessive protection can lead us to move less, move in more guarded and less variable ways, and can ultimately have a negative effect on the body and stall the healing process. 

It’s unclear as to why exactly this happens, but we do know it is based on a multitude of factors. 

But one thing that is clear is that we can upgrade our software to reduce pain, reduce sensitivity, and recover.

An Intentional Software Update

How do we retrain pain and other protective software programs to return to their normal protective settings? The key lies in the bridge between hardware and software: Data.

To give the pain system a less-protective software update, we need more accurate data collection and interpretation, and we need to get new data that nudges the software in the right direction.

More accurate data collection and interpretation is all about building and refining our awareness of the information that is coming in and learning what it means. This can look like:

• Awareness of pain, it’s patterns, it’s quality

• Awareness of cause and effect relationships with regard to the pain and other related factors

• Awareness of other sensations that are present in our bodies

• Awareness, experimentation, and refinement of our movements

• Awareness of other lifestyle factors that may be off-balance

New data collection is all about flooding our bodies with data that nudges the pain system in the direction of less protection. This can look like: 

• Getting clear on goals and tracking progress

• Engaging in enjoyed and purpose-driven activities

• Exercising

• Socializing

• Getting good quality sleep

• Eating nutritious foods

• Other positive health behaviors

As incoming data is interpreted with more accuracy and the system is flooded with new safety-inducing data, the software will inevitably update to a less protective setting while the organism (you) moves ever closer to its goals. 

The Fundamental Flaw

There is a fundamental flaw in this metaphor, which you may have already picked up on. And it is the fact that we cannot truly separate the hardware and the software. The hardware is infused with and influenced by the software, and vice versa. 

For example, where does the brain (an organ—hardware) end and the incredible number of neurological processes and interactions (software) begin?

The importance lies in understanding that there are both hardware and software components to all of us (humans) and all aspects of life (movement, pain, etc.). Artificially separating them, as we have done today, can be useful for furthering our understanding. And with our greater understanding, we can then put the pieces back together, or better yet realize that they were never truly able to be separated in the first place.

Happy updating,

Andrew