Somehow predictably, meditation, as a concept, has been very much twisted, transformed and modified in the Western part of the world. I said “predictably”, because there is always an acceptable degree of transformation to be expected in any cultural interaction. When two cultures collide, concepts are adapted simply by translating them from one language to another. Meditation had its fair share of mistranslations, adaptations or quite profound modifications of its original meaning. I think it’s probably one of the most misunderstood concepts of Eastern philosophies, especially Buddhism (being surpassed only by Tantra in this regard, but this is a topic for another post).
Is Meditation A Mind Spa?
Nope, I’m sorry, it isn’t. Though this is how it is “marketed” in the vast majority of workshops or retreats, meditation is far from being a relaxation ritual for the mind. If anything, meditation is a martial art for the mind, not a spa.
Emptying your mind from thoughts, or “not thinking at anything” is also a very poor way describe it. It’s impossible not to think at anything. The mind is always generating thoughts and it’s grasping at things. Even when you think “not to think at anything”, you’re actually thinking how “not to think at anything”, which is, at least for me, quite hilarious. The very attempt of stopping the flow of thoughts is simply futile and this is not meditation.
So, for the geeks out there who crave to understand meditation, what is it, then?
Debugging Spaghetti Code
Let’s start with a project you’re working on. As you start with an initial structure, and, probably, some scaffold, you keep adding features to it. You add classes, functions, extensions, modules, whatever your language / projects needs.
In an ideal world, we will always have the time – or the necessary knowledge, or clairvoyance – to add all these modules in a clear, structured, predictable, easy to understand structure. Alas, this is never happening (at least not in my experience). There is always something that comes up first, some bridge we need to write, some patching we need to do, some quick function we need to draft “to keep the project floating”. And, sooner or later, we end up with the dreadful “spaghetti code” project, the one that we will keep patching up and adding stuff on top of it, relentlessly.
It’s pretty much how life is. One day we believe we have “everything laid out”, that we know the direction, we have the resources, the trust, the clarity and anything else we need to keep our journey straight, and then, booom! Life happens. And we have to take a detour, to stop, to retreat even, in order to cope with whatever life is throwing at us.
Our lives are a big, twirled, “spaghetti code” project. We’re doing everything we can to keep the compilation going on, to implement whatever functions we think will be useful and to comply with all the required APIs. Sometimes, our “spaghetti code” even uses classes, functions, or inheritance from other projects (think at your parents, your siblings, or any of your long-term relationships) and we have little to no control over that source code. We can only modify our own implementation of it.
But I’m getting ahead of myself. Back to our software project.
As you stare at this convoluted, twisted spaghettis of code trying to understand what specific part crashes your project, you decide to use a debugger. You set up some break points, which will reveal the values of some variable at various points in the code, and recompile, hoping to get the necessary insight to untangle the code.
Sometimes it works from the first try, sometimes – more often than not, to be honest – it doesn’t. So you get back, pick other variables, restart compilation and pay attention to everything that appears on the screen. And so on and so forth. You keep going back to the most convoluted and most untangled part of the code, poking at it with patience and curiosity, hoping to understand what’s going on.
This process of looking at your own reactions and thoughts, unfolding unpredictably – just like spaghetti code is created – and trying to understand which of them are causing you suffering, and why, this is meditation. You focus on some recurring thoughts or patterns, just like you pick your variables, and keep recompiling – meaning you bring your mind focus back to them – until you start to get the gist of it.
Eventually, some patterns will be solved. Just like you apply patches to your debugged code, slowly, some thoughts and behavioral patterns will start to break down, to be solved, to be patched and your life project will crash less and less.
Before that happens, though, there will be a lot of frustration. You will stare at the monitor in tears, trying to understand “why this is happening to me?”, you will Google it, hoping for quick resolution, you will go out and ask on the StackOverflow of life to see if anyone else experienced the same problem, and so on, and so forth.
It’s ok. Allow yourself to go through the process.
Because most of the code you wrote for your life was added on autopilot. You weren’t even aware that you’re writing code, you were just going around, compiling whatever functions you had available.
But as the convolution, the entanglement of your own spaghetti code is becoming more and more complex, and some of the badly coded functions and classes are starting to fire, crashing your life when you’re least expecting it, you will understand the importance of thorough, constant and patient debugging.
The more you do it, the clearer your source code.