If you’re defining yourself as a geek, then the term “continuous integration” may sound familiar to you. But for all the others, let me clarify some things.

According to Wikipedia:

In software engineering, continuous integration (CI) is the practice of merging all developers’ working copies to a shared mainline several times a day.

The main reason for this is, as surprising as it sounds, change.

Following the same Wikipedia definition:

When embarking on a change, a developer takes a copy of the current code base on which to work. As other developers submit changed code to the source code repository, this copy gradually ceases to reflect the repository code. Not only can the existing code base change, but new code can be added as well as new libraries, and other resources that create dependencies, and potential conflicts.

Now that everybody knows what we’re talking about, let’s get back to that path to enlightenment.

How Do You Evaluate Your Practice?

It’s very common to think at your practice in absolute terms. Especially in the Western culture, in which an outside savior is very common (Jesus who will take upon him your sins, or an external judge who will give you “justice”) there is this idea of a fixed event, when everything will be analyzed, given points and results announced. There will be a certain “judgement day” when everything will make sense, and this point is in the future and we have to be prepared for it, we have to accumulate merit, so when the judge comes, the tally will be positive.

For many people, this event is “death”. Another common popular belief is that, just before you die, you “see” your entire life in fast forward. And after that fast forward movie, you will either walk through a circle of light, or…

As I’ve never had a near death experience, and I can’t (clearly) remember something form before this current life cycle, I can’t contradict these.

But, just by trying to understand, with my limited experience and knowledge, how this path to enlightenment works, I came to a slightly different conclusion.

And this conclusion is, in short, that there is no exam. There is no judgement day.

My reasoning is very simple: if such an event will exist, then time, as we understand it, has to stop. Somehow, the flow must be stopped, so the points can be added. But, mind you, if time stops, there will be no room left for any event whatsoever, because that’s exactly how events are working: they need some time to manifest, they need a beginning and an end that defines them.

Try to stop for a second and ponder this.

Ok, now let’s move forward.

If there is no fixed event in which your past life is analyzed, then the only logical conclusion is that tallying is taking place, well, always.

It’s a continuous process. It’s happening all the time. It’s just like continuous integration. You have to always come back to your previous version, identify changes, solve conflicts and try to integrate everything together.

Citing again from Wikipedia:

The longer development continues on a branch without merging back to the mainline, the greater the risk of multiple integration conflicts and failures when the developer branch is eventually merged back.

So it’s all happening now. Right now.

The path to enlightenment is a process, not a destination.

It’s something that you’re walking all the time, even when you’re not. Even when you err, when you get lost, you’re still on the path to enlightenment, as long as you keep coming back, as long as you keep merging the modifications to whatever you’ve been doing before, integrating and adjusting as time goes by.

The Salt And The River

I get the feeling that my geek friends are already understanding this. But for those who are not into this geeky talk, I have another look at it, more story-telling-ish.

Once upon a time, a student asked his master about negative karma. How does this work? Is there a way to offset it somehow? If the law of karma states that every effect comes from a cause, does it mean that once we’ve generated some negative karma we’re doomed?

The master asked his student to go out and take some salt on both his palms, the same quantity of salt. Then he asked him to put the salt from one hand in a bowl of water sitting on the table. The student put the salt, watching the bowl almost overflowing.

“Now drink it”, asked gently the master.

The student drank the concoction, turned blue and felt really sick.

“Now let’s go to the river”, said the master.

Once they arrived to the river, the master asked the student to throw the salt he was still carrying in this other palm into the river. The student threw it away, and the salt instantly dissolved and almost disappeared.

“Now drink some water from the river”, asked gently the master.

The student drank and, if it weren’t for the previous concoction, which left some bad taste into his mouth, he couldn’t even tell if there was some salt in the water or not.

“Now, continued the master. Let’s say salt is ‘bad’ karma and water is ‘good’ karma. There’s no such thing as ‘good’ or ‘bad’, but in this case it’s easy to understand how karma works, because these two, salt and water, are offsetting each other, are opposed in some way. When you mixed some ‘bad’ karma in a limited amount of ‘good’ karma, you felt the effects badly. But when you mixed some ‘bad’ karma with an always growing, always moving, always flowing, amount of ‘good’ karma, the ‘bad’ karma basically disappeared.

That’s how karma works. It is always manifesting, just like the river. And it is up to you what you manifest, stones of salt, or rivers of water”.

Or, in more modern, geekiest terms: keep doing that continuous integration thing, and, at some point, your software will not only work as intended and be free of bugs, but you will also play around quite nicely with other geeks sharing the same repository.

Image by LoggaWiggler from Pixabay