I am a person who has a fascination with code.
There is a logic to that logic. There is a certainty in specificity.
Even when things seem illogical, there is is a logic to the lack of logic.
I bring this up, I suppose, because it’s a handy segue that I can connect to later because I tend to write in loops.
Perhaps you’ve noticed.
I find myself at a crossroads of sorts.
But no. Not a crossroad. That alludes to the concept of multiple paths that branch from the direction that I now find myself. This implies that I’m at (0,-1) and am facing the choice to pursue (0,1), (1,0), or (-1,0).
This is inaccurate and I tend to strive for accuracy. Accuracy matters. Precision, however, matters more. Accuracy is the ability to hit the bull’s eye. Precision is the ability to keep hitting it.
Precision is repeatability.
Don’t worry, I’ll tie into that as well. Circles within circles within circles.
You know the drill.
I find myself at a division in the road. As though I’m at (0,-1) and I’m looking at (-1,1) or (1,1).
One path will lead me somewhere that I would like to go. I’m allowed to go there. But I should not go there because, in so doing, I feel that I would cause discomfort to another. I do not like being the cause of discomfort.
This is not to say I’ve never been the cause of discomfort, only that I find no joy, solace, or catharsis in doing so.
This brings to mind a few logical questions. Basic if/thens, if you will. Basic if/thens even if you won’t.
The most flawed, however, begins with, “What would they…”
The end of the statement is irrelevant. It is not a question that can be answered without some degree of assumption. It is not a question that can be answered with specificity. It is, most importantly, not a question that matters.
It doesn’t matter because path (-1,1) violates my code.
Not my code – 01010010110101001 – code.
It violates my Code.
This is not to say I’ve never violated my own Code. We all have Codes. We all violate our Codes. To see a failure of our own algorithms and remain pursuant of further failures, one must find themselves asking, “Is this really my Code, or do I simply claim it? If it’s the latter, then what is my Code?”
A person should know their Code.
A person should know their code – 001010110100110110 – code – to the best of their ability.
We can’t ever really know the bits and bytes of ourselves, but we are not ignorant of all the values – hexadecimal or otherwise.
To strive to pursue our Code is accuracy.
To continue pursuing it with consistency…that is precision.
Precision is important.
By my Code, I have a directive that was imparted at a time prior. A time that was not recent. In the time between, there have been other directives. There have been variables that have adjusted various elements that are tangent to that aforementioned directive.
There has not been a removal of said directive.
I find myself bound by my Code while simultaneously threatening to break it.
Not a real threat.
I don’t make real threats.
I abhor violence in all its forms.
This is not to say that I’ve never been part of an algorithm whose end value was violence – direct or otherwise. But this does not preclude a desire to insert myself into such algorithms and go seeking those end results.
To do so is a violation of my Code, even if it does not violate my code.
I find myself, however, with those divergent paths. Paths that tell me that to pursue (-1,1) would be to break my Code. But then, so too does (1,1). It is a different facet of the same Code. A different code within my code.
That breach, however, would cause me discomfort.
I don’t particularly care for discomfort. I do not pursue it.
This is not to say that I’ve never pursued it – indirectly or otherwise – but I do not seek ways to insert myself into that construct intentionally.
In all my failings, I do not abide the notion of “Since I slipped, I might as well fall.”
To do so would be a violation of my Code, and if I start seeking breaches to my own logic, then I must ask myself, “Is this really my Code, or is this simply what I tell myself?”
The end determination, of course, is simple. It is precise. It is very specific.
One path would seem to cause discomfort in another, the other would cause discomfort in myself. Both could potentially hold any number of other end results. But one does not account for unknowns when one does not know the unknowns that one is not accounting for.
If I must choose between my own discomfort and another’s, I cannot choose theirs. It would be inconsiderate.
This is not to say that I’ve never been inconsiderate. We all have been. We all are, from time to time. But when one says that they do not play with matches, they must be aware that others might. We cannot logically say that we can still play with matches merely because we have witnessed another doing so.
In short – the sins of another do not validate or defend my own.
Granted – I do not believe in sins, but the sentiment holds true. If I allow myself to circumvent my own logic because another has circumvented their own logic – then I must ask myself: Do I have a Code, or do I operate on a system of strong suggestions?
So I find myself looking at the slow-motion approach of (-1,1) and (1,1) and I do not need to ask myself, “What is my Code?” because I know what my Code is, even if I don’t fully understand what my code is.
My Code does not seek to cause discomfort in others unnecessarily, and I do not believe there is ever a necessity to cause discomfort. And while I certainly have caused discomfort, in both myself and others, I do not seek this end result. When facing new iterations of that same algorithm, I like to believe that I do not pursue duplicate paths that lead to duplicate values that I did not desire when they first appeared.
If I did not do better than I did before, I would be in violation of my Code…and my code. And I know what my Code is.
A person should know what their Code is.