Like typecasting, it is a whole new set of properties and functions. An integer isn't a string, but they can both be printed. I see our sin like that. First we are shackled to it, unable to choose differently. But the new one is openness. We can choose sin, or choose redemption, and live in a different way. Even if some of our actions look the same. We still eat food like we did before, we still need sleep and crave friendship, but were not doing it as a way to justify our lives and control the universe, instead we can do it as part of God's creation and living out His purpose.
Typecasting from worldly to redeemed in Christ is immediate, but painful. Imagine all those errors when the familiar calls are made to old functions which have disappeared. Errors, breaking, failure. But God is the error handling for this, we are an emulated process now executing inside His structure, and bad calls can be handled. He is our nanny process, our host system, our hypervisor.
~~~
I think there is an interesting caveat to the change in function calls though, because we can still make the old ones. Just because we aren't obliged to sin, it doesn't mean we can't choose it. Freedom in this model means that we could continue in the way we had been acting, with God insulating us from the damages caused when we try to execute a bad command. Or maybe he would let it execute as we expect, let us experience whatever the pain is that is coming, but ultimately if we're "in Him" then it won't permanently destroy us.
It's a strange concept to try and put to programming since it's more our choice than normal programmatic flow. But I look at it a bit like badly bodged together wrapper scripts, which lets bad code limp on for years, with more and more layers of cruft added, or taking the better steps to rewrite the system and make it work properly.
Let's build on that idea. A very popular concept within the world of agile programming is this whole "launch and iterate" model. What would that look like for the human? How do we iterate? Well, if we're convinced that the old way of functioning is sufficient and everything around us must bend to our desires, then we are just adding more and more layers of abstraction. And with more layers between us and others, we're making more complicated scenarios which are bound to breakdown at some point. There will always be an edge case that will break these makeshift interfaces.
So let's say we rework the system. This means, as people, we change ourselves. It's hard. It admits we're imperfect, and often it hurts. You go through the same debugging steps, finding the things that used to work that don't anymore and you have to repair them. And sometimes you find the way you did it previously was just horribly dysfunctional, and can be significantly improved. So you refactor, and you improve yourself.
And you'll probably find others still need those cumbersome layers of abstraction to interact with you, or sometimes they just don't know how to handle the new data coming at them. But one thing you definitely learn from this model is that you can't change the other object! Imagine how much that changes our normal ways of social difficulty. As people, myself included, tend to see all problems as being the fault of those around me. Someone else caused this issue, if only they interacted MY way this never would have happened. Those thoughts are from us looking at the world as something that needs to be modified to fit our limited commands. Not that we ought to change to better interact with the world.
~~~
So merging these back together, I picture inheritance as the immediate change over from being stuck with one functional model, and moving to a much more versatile one. The one that inherits from a much better, more capable model, which is Jesus. And then the process of sanctification is where we launch an iterate on our own being. We wrestle with how we act, what we want, what we do, why we do it, and find that we're slowly reshaping our actions from "why can't everyone conform to me?" and into "how can I help others and interact better?"
And as a bonus, under the second model, we're no longer constantly angered by others not matching what we want, because we're sharing in the burden of communication.
~~~
I think there is an interesting caveat to the change in function calls though, because we can still make the old ones. Just because we aren't obliged to sin, it doesn't mean we can't choose it. Freedom in this model means that we could continue in the way we had been acting, with God insulating us from the damages caused when we try to execute a bad command. Or maybe he would let it execute as we expect, let us experience whatever the pain is that is coming, but ultimately if we're "in Him" then it won't permanently destroy us.
It's a strange concept to try and put to programming since it's more our choice than normal programmatic flow. But I look at it a bit like badly bodged together wrapper scripts, which lets bad code limp on for years, with more and more layers of cruft added, or taking the better steps to rewrite the system and make it work properly.
Let's build on that idea. A very popular concept within the world of agile programming is this whole "launch and iterate" model. What would that look like for the human? How do we iterate? Well, if we're convinced that the old way of functioning is sufficient and everything around us must bend to our desires, then we are just adding more and more layers of abstraction. And with more layers between us and others, we're making more complicated scenarios which are bound to breakdown at some point. There will always be an edge case that will break these makeshift interfaces.
So let's say we rework the system. This means, as people, we change ourselves. It's hard. It admits we're imperfect, and often it hurts. You go through the same debugging steps, finding the things that used to work that don't anymore and you have to repair them. And sometimes you find the way you did it previously was just horribly dysfunctional, and can be significantly improved. So you refactor, and you improve yourself.
And you'll probably find others still need those cumbersome layers of abstraction to interact with you, or sometimes they just don't know how to handle the new data coming at them. But one thing you definitely learn from this model is that you can't change the other object! Imagine how much that changes our normal ways of social difficulty. As people, myself included, tend to see all problems as being the fault of those around me. Someone else caused this issue, if only they interacted MY way this never would have happened. Those thoughts are from us looking at the world as something that needs to be modified to fit our limited commands. Not that we ought to change to better interact with the world.
~~~
So merging these back together, I picture inheritance as the immediate change over from being stuck with one functional model, and moving to a much more versatile one. The one that inherits from a much better, more capable model, which is Jesus. And then the process of sanctification is where we launch an iterate on our own being. We wrestle with how we act, what we want, what we do, why we do it, and find that we're slowly reshaping our actions from "why can't everyone conform to me?" and into "how can I help others and interact better?"
And as a bonus, under the second model, we're no longer constantly angered by others not matching what we want, because we're sharing in the burden of communication.
