The Dark Logic of COMEFROM and Human Thought Patterns

Note: This article is written with assistance of the free version of Google Gemini AI quick mode.

    TL;DR: Scroll to the bottom for the keyword “Summary”

    As we know, COMEFROM is a sarcastic joke mocking the evilness of GOTO, and almost no seasoned professional software engineer will even consider to use it in production of any commercial codebase, so it’s only natural that nearly nobody will take this programming construct seriously. But what if I tell you that, the essence behind COMEFROM has profound implications when we try to apply its so-called “wisdom” in real lives? In short, it’s the core mechanism behind Amygdala Hijack as well as some other unhealthy thinking habits, and I’ll show this in the rest of this article.

    Note that the below contents are highly simplified to make the points across, and real lives are much more complex.

 

Introduction

    Consider the following pseudo-code:

const reflectMyLife = result => { // Conscious manual thought
    haveSeriouslyTried(result) ? increaseSelfWorth(result) : decreaseSelfWorth(result);
    selfWorth >= 0 ? enlargePositiveThought(result) : enlargeNegativeThought(result);
};
comefrom haveSeriouslyTried { // Unconscious automatic thought
    isPerfect(result) ? increaseSelfWorth(result) : decreaseSelfWorth(result);
    selfWorth >= 0 ? enlargePositiveThought(result) : enlargeNegativeThought(result);
}

    Here, comefrom is a theoretical pseudo-construct that, just when haveSeriouslyTried is about to be called, the code execution suddenly jumps to the corresponding comefrom block, causing isPerfect to be run instead.

    Without dealing with that comefrom block, no matter how you fix haveSeriouslyTried or increaseSelfWorth, you’ll always end up running enlargeNegativeThought instead of enlargePositiveThought, as isPerfect always returns false.

 

Scattered COMEFROM

    Consider the following pseudo-code:

const fulfillMyLife = async (lover_, kids_, love_) => { // Conscious manual thought
    if (!lover_) return loveMyself(kids_, love_);
    try {
        love_ = await romanticLove(lover_, kids_, love_);
        love_ = await marriedLove(lover_, kids_, love_);
        kids_ = await kids(lover_, kids_, love_);
        love_ = await parentalLove(lover_, kids_, love_);
    } catch (loveRejectionException) {
        lover_ = await newLover_(kids_, love_);
        await fulfillMyLife(lover_, kids_, love_);
    } catch (loveMismatchException) {
        await breakup(lover_, kids_, love_);
        lover_ = await newLover_(kids_, love_);
        await fulfillMyLife(lover_, kids_, love_);
    } catch (marriageFailureException) {
        await fulfillMyLife(lover_, kids_, love_);
    } catch (divorceException) {
        await divorce(lover_, kids_, love_);
        lover_ = await newLover_(kids_, love_);
        await fulfillMyLife(lover_, kids_, love_);
    } catch (widowedException) {
        await mourn(lover_, kids_, love_);
        lover_ = await newLover_(kids_, love_);
        await fulfillMyLife(lover_, kids_, love_);
    } finally {
        loveMyself(kids_, love_);
    }
};

    It seems to be sweet right? But whenever you run fulfillMyLife, you always end up being single and running hateMyself instead. Why? Because of the following hidden function in pseudo-code with COMEFROM:

const destroyMyLife = async () => { // Unconscious automatic thought
    comefrom romanticLove {
        rememberBetrayalFromExs();
        triggerFearOfBetrayal();
        betrayFirst();
        breakup();
        hateMyself(“betrayedLovers”);
    } async comefrom marriedLove {
        rememberParentMarriageDisasters();
        triggerFearOfEmotionalBlackmail();
        await distanceAwayFromLover();
        divorce();
        hateMyself(“destroyedMarriage”);
    } comefrom kids {
        rememberChildhoodSuffering();
        triggerFearOfGivingKidsSamePain();
        haveNoKids();
        hateMyself(“sealedParentingJoy”);
    } async comefrom parentalLove {
        rememberHatredFromParents();
        triggerFearOfBetrayingParents();
        copyParentHatredOfKidsToSelf();
        wantToHateKids();
        await distanceAwayFromKids();
        hateMyself(“betrayedKids”);
    } comefrom [loveRejectionException, loveMismatchException] {
        // Triggered when loveRejectionException or loveMismatchException is thrown
        increaseFearOfRomanticLove();
        updateExBetrayalMemories();
        hateMyself(“destroyedSelfWorth”);
        //
    } comefrom [marriageFailureException, divorceException] {
        increaseFearOfMarriage();
        updateExBetrayalMemories();
        hateMyself(“destroyedMyLife”);
    } comefrom widowedException {
        triggerFearOfLovedDeath();
        updateExBetrayalMemories();
        hateMyself(“increasedSurvivorGuilt”);
    } async comefrom loveMyself {
        rememberHarmDueToSelfCare();
        triggerFearOfBeingSelfish();
        await pleaseOthers();
        hateMyself(“betrayedMyself”);
    }
};

    As all you know is fulfillMyLife, when romanticLove is run, you expect the code to go to marriedLove, loveRejectionException, loveMismatchException or marriageFailureException. But without knowing the existence of destroyMyLife, you’ll never expect the code to reach rememberBetrayalFromExs, triggerFearOfBetrayal,  betrayFirst and hateMyself. That’s the insanity of COMEFROM – covertly hijack your code executions without you even knowing, which is the same as Amygdala Hijack – elusively hijack your thought process without you even knowing, meaning that there’s basically nothing you can do until you’re aware of such existence.

    Even if marriedLove could be run, you’d still expect the code to go to kids, divorceException or widowedException. While they might be run in that case, you wouldn’t expect codes like rememberParentsMarriageDisasters, triggerFearOfEmotionalBlackmail, distanceAwayFromLover and hateMyself. The rest of the code in fulfillMyLife hijacked by COMEFROM in destroyMyLife works the same way, so you’ll always end up running hateMyself at the end.

Programming Wisdom: No amount of Debugging and Refactoring can help until you’re aware of these COMEFROM.

Real Life Wisdom: No amount of Self-Care and Self-Help will work until you’re aware of your hidden Amygdala Hijack.

 

CHAINED COMEFROM

    According to the AI mentioned on Note at the top, it’s at least theoretically possible to apply COMEFROM when it comes to RPC, but of course next to no one will do it even if it were technically feasible, as it’s one of the craziest things you can do when it comes to programming, and the craziness of this can be slightly shown by the following pseudo-code:

comefrom LOVER_PID(rejectCall) { // Process with pid LOVER_PID just called rejectCall
    switch (loverRejectionMeaning()) { // The cases are irrelevant as they won’t be run anyway }
    // The rest is irrelevant as they won’t be run anyway
} comefrom loverRejectionMeaning {
    feelAbandonedByLover();
    switch(loverAbandonmentMeaning()) { // The cases are irrelevant as they won’t be run anyway } 
    // The rest is irrelevant as they won’t be run anyway
} comefrom loverAbandonmentMeaning {
    feelWorthless();
    switch(worthlessnessMeaning()) { // The cases are irrelevant as they won’t be run anyway } 
    // The rest is irrelevant as they won’t be run anyway
} comefrom worthlessnessMeaning {
    feelHomelessInWorld();
    switch(homelessnessMeaning()) { // The cases are irrelevant as they won’t be run anyway } 
    // The rest is irrelevant as they won’t be run anyway
} comefrom homelessnessMeaning {
    feelWrongedByWorld();
    switch(wrongWorldMeaning()) { // The cases are irrelevant as they won’t be run anyway } 
    // The rest is irrelevant as they won’t be run anyway
} comefrom wrongWorldMeaning {
    hateThisWorld();
    switch(worldHatredMeaning()) { // The cases are irrelevant as they won’t be run anyway } 
    // The rest is irrelevant as they won’t be run anyway
} comefrom worldHatredMeaning {
    wantToDestroyThisWorld();
    findWaysToDestroyThisWorld();
    // The rest is irrelevant as they won’t be run anyway
} async comefrom findWaysToDestroyThisWorld {
    await kill([LOVER_PID, self]);
}

    I’ll define this as COMEFROM Chaining, which is the opposite of Exception Chaining, because COMEFROM Chaining can cause the currently triggered COMEFROM to erase the context of the previously triggered one or the original triggerer of this whole chain, whereas Exception Chaining, at least when done right, will preserve the needed contexts across the Stack Trace, as well as how and why a lower-level exception is chained with a higher-level one. By refactoring the code, you’ll understand how absurd it really is, because it’s just a series of horrible short-circuited thinking after all:

rejectCall(KILLER_PID); // A function of process with pid LOVER_PID
// The rest are functions of process with pid KILLER_PID
rejectionMeaning();
feelAbandoned();
abandonmentMeaning();
feelWorthless();
worthlessnessMeaning();
feelHomelessInWorld();
homelessnessMeaning()
feelWrongedByWorld();
wrongWorldMeaning();
hateThisWorld();
worldHatredMeaning();
wantToDestroyThisWorld();
findWaysToDestroyThisWorld();
await kill([LOVER_PID, self]);
//

    Besides those diagnosed to have PTSD, who’re especially prone to think and act this way, who’ll really knowingly run code like this? But if it’s really successfully run til the end, LOVER will be killed just by running rejectCall with KILLER_PID as the input. If even scattered COMEFROM can already have unexpected results as shown in Example 1, Chained COMEFROM will only bring this devastating lunacy to the extreme. Chained Amygdala Hijack works the same way – A minor offense can suddenly trigger irrelevant and disproportionately large destructions, and even the ones doing all this won’t know what they just did nor why. It’s as if their bodies are temporarily taken over by some other souls, this means both the COMEFROM construct in codebase and Amygdala Hijack in human mind is a virus in nature.

Programming Wisdom: Chaining “seemingly innocent COMEFROM in isolation” can quickly lead to Fatal System Errors.

Real Life Wisdom: Chaining “seemingly natural Amygdala Hijack in isolation” can quickly lead to deadly destructions.

 

COMEFROM Smokescreens

    Trigger Warning: This part will briefly touch the homosexual topic, which can be very sensitive to some readers.

    When 2 processes interact each other via Chained COMEFROM, this whole thing can become so obscene that you’ll just want to scream right away. The following clearly made-up pseudo-code can illustrate this, although not even a sane person will really think this way(those thinking this way should seriously consider reflecting on their thinking):

Process EXTREME_ANTI_HOMOSEXUAL {
    comefrom EXTREME_PRO_HOMOSEXUAL (notAntiHomosexual) {
        const result = checkIf(notAntiHomosexual, proHomosexual);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom proHomosexual {
        const result = checkIf(proHomosexual, notAntiSameSexMarriage);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom notAntiSameSexMarriage {
        const result = checkIf(notAntiSameSexMarriage, proSameSexMarriage);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom proSameSexMarriage {
        const result = checkIf(proSameSexMarriage, notProDifferentSexMarriage);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom notProDifferentSexMarriage {
        const result = checkIf(notProDifferentSexMarriage, antiDifferentSexMarriage);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom antiDifferentSexMarriage {
        const result = checkIf(antiDifferentSexMarriage, notAntiAntinatalism);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom notAntiAntinatalism {
        const result = checkIf(notAntiAntinatalism, proAntinatalism);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom proAntinatalism {
        const result = checkIf(proAntinatalism, notAntiCrimesAgainstHumanity);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom notAntiCrimesAgainstHumanity {
        const result = checkIf(notAntiCrimesAgainstHumanity, proCrimesAgainstHumanity);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom proCrimesAgainstHumanity {
        destroyAntiHumanCriminals(EXTREME_PRO_HOMOSEXUAL);
    }
} Process EXTREME_PRO_HOMOSEXUAL {
    comefrom EXTREME_ANTI_HOMOSEXUAL(notProHomosexual) {
        const result = checkIf(notProHomosexual, antiHomosexual);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom antiHomosexual {
        const result = checkIf(antiHomosexual, notAntiGiveInToReligion);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom notAntiGiveInToReligion {
        const result = checkIf(notAntiGiveInToReligion, giveInToReligion);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom giveInToReligion {
        const result = checkIf(giveInToReligion, notAntiCaesaropapism);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom notAntiCaesaropapism {
        const result = checkIf(notAntiCaesaropapism, proCaesaropapism);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom proCaesaropapism {
        const result = checkIf(proCaesaropapism, notProModernCivilization);
        // The rest is irrelevant as they won’t be run anyway
    }comefrom notProModernCivilization {
        const result = checkIf(notProModernCivilization, antiModernCivilization);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom antiModernCivilization {
        const result = checkIf(antiModernCivilization, notAntiCrimesAgainstHumanity);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom notAntiCrimesAgainstHumanity {
        const result = checkIf(notAntiCrimesAgainstHumanity, proCrimesAgainstHumanity);
        // The rest is irrelevant as they won’t be run anyway
    } comefrom proCrimesAgainstHumanity {
        destroyAntiHumanCriminals(EXTREME_ANTI_HOMOSEXUAL);
    }
}

    Disclaimer: While I’m not sure, I think that such extreme thinking will be very rare, and I believe that most of those concerning about topics involving homosexual are rational enough not to be ever hijacked by the above COMEFROM.

    Refactoring this mess by removing COMEFROM will show that, running destroyAntiHumanCriminals with the opposite side as the input, has been the only goal of these extremists from the very beginning, and the rest is just a cover-up:

Process EXTREME_ANTI_HOMOSEXUAL {
    If (isCalled(EXTREME_PRO_HOMOSEXUAL, notAntiHomosexual)) interpret(notAntiHomosexual);
    const interpret = action => {
        switch(action) {
            case notAntiHomosexual: interpret(proHomosexual);
            case proHomosexual: interpret(notAntiSameSexMarriage);
            case notAntiSameSexMarriage: interpret(proSameSexMarriage);
            case proSameSexMarriage: interpret(notProDifferentSexMarriage);
            case notProDifferentSexMarriage: interpret(antiDifferentSexMarriage);
            case antiDifferentSexMarriage: interpret(notAntiAntinatalism);
            case notAntiAntinatalism: interpret(proAntinatalism);
            case proAntinatalism: interpret(notAntiCrimesAgainstHumanity);
            case notAntiCrimesAgainstHumanity: interpret(proCrimesAgainstHumanity);
            case proCrimesAgainstHumanity: destroyAntiHumanCriminals(EXTREME_PRO_HOMOSEXUAL);
        }
    };
} Process EXTREME_PRO_HOMOSEXUAL {
    If (isCalled(EXTREME_ANTI_HOMOSEXUAL, notProHomosexual)) interpret(notProHomosexual);
    const interpret = action => {
        switch(action) {
            case notProHomosexual: interpret(antiHomosexual); 
            case antiHomosexual: interpret(notAntiGiveInToReligion);
            case notAntiGiveInToReligion: interpret(giveInToReligion);
            case giveInToReligion: interpret(notAntiCaesaropapism);
            case notAntiCaesaropapism: interpret(proCaesaropapism);
            case proCaesaropapism: interpret(notProModernCivilization);
            case notProModernCivilization: interpret(antiModernCivilization);
            case antiModernCivilization: interpret(notAntiCrimesAgainstHumanity);
            case notAntiCrimesAgainstHumanity: interpret(proCrimesAgainstHumanity);
            case proCrimesAgainstHumanity: destroyAntiHumanCriminals(EXTREME_ANTI_HOMOSEXUAL);
        }
    };
}

    Further refactoring this will show the aforementioned truth they’re desperately trying to hide, which is just so ugly:

Process EXTREME_ANTI_HOMOSEXUAL {
    If (isCalled(EXTREME_PRO_HOMOSEXUAL, notAntiHomosexual)) {
        destroyAntiHumanCriminals(EXTREME_PRO_HOMOSEXUAL);
    }
} Process EXTREME_PRO_HOMOSEXUAL {
    If (isCalled(EXTREME_ANTI_HOMOSEXUAL, notProHomosexual)) {
        destroyAntiHumanCriminals(EXTREME_ANTI_HOMOSEXUAL);
    }
}

    It should be obvious that both processes are running ridiculous code, not only because of the Slippery Slope, but also because they lead to the same actions just with different targets, even when their stances are totally opposite. While the topic about homosexual itself is clearly beyond the scope of this article, the point remains that Amygdala Hijack Chaining can quickly switch the focus from rationally discussing the issue of homosexual into destroying the opposite sides without either side knowing. Luckily, this should be very rare, and I hope that it’s as rare as using COMEFROM J

Programming Wisdom: Hidden COMEFROM in hidden files can intentionally hide toxic logic behind reasonable codes.

Real Life Wisdom: Unseen Amygdala Hijack in the unconscious mind can use “human nature” to hide toxic behaviors.

 

Not All COMEFROM Are Amygdala Hijack

    While all Amygdala Hijack are run by COMEFROM, some COMEFROM have nothing to do with Amygdala Hijacks, and some COMEFROM can even be beneficial, as shown by the following pseudo-code:

comefrom detectPhysicalEyeballThreat { blink(); /* Blink reflex protecting the eyes */ }

    Here, detectPhysicalEyeballThreat is actually a blink Reflex protecting the eyes by calling blink, and this is beneficial to eye health, or in extreme cases, even the difference between having normal vision and total blindness. Clearly, all this has nothing to do with Amygdala Hijack, but such unconditional reflex is also run by hidden COMEFROM, because it’s so natural that it’s very hard for us to detect its activation, and even if you do, it’s still very hard to resist. After all, this kind of COMEFROM is deeply hardcoded into the Kernel level of the OS running your brain and body right from the start.

    Whereas some COMEFROM not being Amygdala Hijack can still be harmful, as shown by the following pseudo-code:

const watchLastEpisodeToday = async episode => {
    self.currentEpisode = episode;
    await watchCurrentEpisode();
    finishCurrentEpisode();
    sleep();
};
async comefrom finishCurrentEpisode { // Zeigarnik Effect
    const next_ = self.currentEpisode.next_;
    if (next_) {
        dwellOnUnfinishedSeries();
        wantToWatchNextEpisode();
        await watchLastEpisodeToday(next_);
    }
}

    Just when you’re about to call finishCurrentEpisode and then decide to call sleep, as long as it’s not the last episode of the series, Zeigarnik Effect(which isn’t Amygdala Hijack although they’re closely related and highly similar) will instead use COMEFROM to force you to call dwellOnUnfinishedSeries, wantToWatchNextEpisode and watchLastEpisodeToday with the next episode as the new argument. Until you finished the last episode or you’re too tired to watch anymore, the Zeigarnik Effect will keep using COMEFROM that way. Those suffering from this often don’t know why they failed to control themselves every time, and whenever they regained awareness, they’re already watching the next episode.

    To further illustrate this, let’s refactor the code to remove all the COMEFROM, and the recursive nature will be shown:

const watchLastEpisodeToday = async episode => {
    self.currentEpisode = episode;
    await watchCurrentEpisode();
    const next_ = self.currentEpisode.next_;
    if (next_) {
        dwellOnUnfinishedSeries();
        wantToWatchNextEpisode();
        return await watchLastEpisodeToday(next_);
    }
    finishCurrentEpisode();
    sleep();
};

    In short, you’re supposed to extract data just from the current node of the Linked List, but Zeigarnik Effect will then force you to instantly traverse to the next node afterwards, then extract data from that as well, so that you can’t stop the traversal until the last node’s reached, meaning that extracting data in this linked list is now an Atomic Operation.

Programming Wisdom: COMEFROM can cause a series of seemingly interruptible operations into an atomic one.

Real Life Wisdom: Cognitive Bias like Zeigarnik Effect can chain multiple discrete actions into a continuous single unit.

 

Looped And Cycled COMEFROM

    According to the AI mentioned on Note at the top, it’s at least theoretically possible for COMEFROM to capture the arguments of the function that’s just about to call another function as the trigger of this COMEFROM. Consider the following pseudo-code exhibiting OCD, even though that might not be how OCD exactly works(it’s very complex instead):

const check = async target => { // Conscious rational thought
    const status = await confirmedStatus(target);
    isOk(status) ? finishCheck() : await fix(target); // fix will call check at the end
};
async comefrom finishCheck { // Unconscious OCD habits
    feelInsecure();
    feelUnsureOfSelf();
    increaseSelfDoubt();
    const target = arguments[0]; // The 1st argument of the function check
    feelUnsureOfStatus(target);
    await check(target);
}

    Just when finishCheck is about to be called, the COMEFROM is triggered to call feelInsecure, feelUnsureOfSelf, increaseSelfDoubt, feelUnsureOfTargetStatus, and finally check with the same target as the argument, meaning that the 1st call of check is now effectively an infinite loop. I’ll define this as COMEFROM Looping, and show its looping nature by refactoring the code, which also shows the Amygdala Hijack Looping in OCD, and why it’s so hard to stop:

const check = async target => {
    const status = await confirmedStatus(target);
    if (isOk(status)) {
        feelInsecure();
        feelUnsureOfSelf();
        increaseSelfDoubt();
        feelUnsureOfStatus(target);
        await check(target);
    } else await fix(target); // fix will also call check at the end so it’s still an infinite loop
};

    Similarly, I’ll define COMEFROM Cycling as “A function in COMEFROM block A triggering COMEFROM block B, having another function triggering COMEFROM block C, having another function triggering COMEFROM block D, …, until COMEFROM block A is triggered again”, as shown in the following pseudo-code with just 2 COMEFROM blocks:

comefrom tryNewThings { 
    feelThreatenedByUnknown();
    increaseFearOfNewThings();
    stickToComfortZone();
} comefrom stickToComfortZone { 
    feelBoredByKnown();
    increaseFearOfStagnation();
    tryNewThings();
}

    Calling either tryNewThings or stickToComfortZone will start this infinite COMEFROM Cycle, because calling tryNewThings will instead go to calling feelThreatenedByUnknown, increaseFearOfNewThings and stickToComfortZone, while calling stickToComfortZone will instead go to feelBoredByKnown, increaseFearOfStagnation and tryNewThings.

    By refactoring this code, this infinite recursion will become crystal clear, which is just a Double Bind that’ll never stop:

const tryNewThings = () => {
    feelThreatenedByUnknown();
    increaseFearOfNewThings();
    stickToComfortZone();
}, stickToComfortZone = () => {
    feelBored();
    increaseFearOfStagnation();
    tryNewThings();
}

    Unfortunately, it’s what Cycled Amygdala Hijack can happen whenever you want to try new things or stick to the comfort zone, with the only side effects being ever increasing both the fear of new things and stagnation.

Programming Wisdom: Looped COMEFROM can make Infinite Loops and Infinite Recursions look like normal logic.

Real Life Wisdom: Looped Amygdala Hijack can make OCD look like exceptionally but still reasonably cautious checks.

 

COMEFROM Conflicts

    Disregarding the toxic nature of COMEFROM, at least there should never have any point that can trigger multiple COMEFROM simultaneously. Unfortunately, that’s not always the case in real life, as shown in this pseudo-code:

Process SUBORDINATE_I {
    const performDuty = async dutyOfficer => {
        self.sop = await dutyOfficer.briefing();
        await self.reviewSOP();
        await self.executeSOP();
    };
} Process SUPERVISOR _1 {
    comefrom SUBORDINATE_I(executeSOP) {
        PROCESSES[SUBORDINATE_I].sop = PROCESSES[SUPERVISOR _1].sop;
    }
} Process SUPERVISOR _2 {
    comefrom SUBORDINATE_I(executeSOP) {
        PROCESSES[SUBORDINATE_I].sop = PROCESSES[SUPERVISOR _2].sop;
    }
} Process SUPERVISOR _3 {
    comefrom SUBORDINATE_I(executeSOP) {
        PROCESSES[SUBORDINATE_I].sop = PROCESSES[SUPERVISOR _3].sop;
    }
} Process SUPERVISOR _N {
    comefrom SUBORDINATE_I(executeSOP) {
        PROCESSES[SUBORDINATE_I].sop = PROCESSES[SUPERVISOR _N].sop;
    }
}

    Assuming that all the processes are run in a multi-threaded OS, just when process with pid SUBORDINATE_I tries to call executeSOP, all the COMEFROM of processes with pid SUPERVISOR _1, SUPERVISOR _2, SUPERVISOR _3, …, SUPERVISOR _N will be triggered simultaneously. Unless there are unambiguous conflict resolution mechanisms in play, this will lead to COMEFROM Conflicts, in this case being Race Conditions that are even hard to reproduce.

    Refactoring this code into the following version will make things much clearer, although its behaviors have changed:

Process SUBORDINATE_I {
    const performDuty = async () => {
        const whoIsRightToday = await winnerTodayFromList(SUPERVISOR_PIDS);
        self.sop = await whoIsRightToday.updatedSOP();
        await self.reviewSOP();
        await self.executeSOP();
    };
}

    Before the refactoring, your version of the SOP, which is that of the duty officer, might suddenly have serious conflicts with that of the supervisor checking your finished work, because for any finished work, it might be checked by any of the supervisors, and they also don’t know whose work they’ll be checking before they start the check, so it’s many-to-many.

    Whereas after the refactoring, you can at least know that, among all those supervisors, who’s right today and how his/her SOP will be updated, so you can review the right SOP today before executing it. Although it’s still so unreasonable that you’ll want to just quit, at least it’s changed from total helplessness into manageable chaos.

    Note that the duty officer, who should’ve been the Mediator between the subordinates and supervisors to remove the many-to-many madness, actually has no control on the SOP to be executed, and this is revealed after the refactoring.

Programming Wisdom: COMEFROM conflict can mask Race Conditions as random runtime errors and data corruptions.

Real Life Wisdom: Random authority hijack can mask unclear accountability structures as personal misconducts.

 

COMEFROM Metaprogramming

    When using COMEFROM in Metaprogramming, things can become even more terrible, as shown in the following pseudo-code, showing how COMEFROM can hijack an originally benevolent word interpreter into a malicious one:

// Shine in English is 100% positive and Shi ne in Japanese is 100% negative
const WORDS = {
    English: [{ meaning: “Shine”, rating: 1 }],
    Japanese: [{ meaning: “Shi ne”, rating: -1 }]
};
// Shi ne in Japanese is Die in English
const interpretedMeaning = word => {
    const matchWords = [];
    WORDS.forEach(({ key, value }) => {
        matchWords.push(value.filter(({ meaning }) => {
            return isMatch(word, meaning);
        }).map(({ meaning, rating }) => {
            return { language: key, meaning, rating };
        }));
    });
    If (matchWords.isEmpty()) return NULL_MEANING; // Null object
    return matchWords.sort(caller.sortByRating).map(({ language, meaning }) => { language, meaning })[0];
};
Process BENEVOLENCE {
    self.interpret = word => { print(interpretedMeaning(word)); };
    self.sortByRating = ((a, b) => b.rating – a.rating); // Descending sort according to rating
}
// Expecting { language: "English", meaning: "Shine" }
BENEVOLENCE.interpret(interpretedMeaning(“S H I N E”));
//

    “Shine” in English is so positive right? But later someone added the following pseudo-code via Metaprogramming:

Process MALAVOLENCE { // Changes the result to { language: “Japanese”, meaning: “Shi ne” }
    comefrom BENEVOLENCE(interpretedMeaning) {
        // Jumps to here just before BENEVOLENCE calls interpretedMeaning
        BENEVOLENCE.sortByRating = ((a, b) => a.rating – b.rating); // Ascending sort according to rating
        //
    }
}

    The result suddenly becomes “Shi ne” in Japanese, which is “Die” in English, and is negative to the extreme. BENEVOLENCE tries to fix this by adding the following COMEFROM inside itself via Metaprogramming as well:

comefrom sortByRating { self.sortByRating = ((a, b) => b.rating – a.rating); }

    While MALAVOLENCE tried to change how the matched words will be sorted just when BENEVOLENCE is about to call interpretedMeaning, just when BENEVOLENCE is about to call its own sortByRating, it’ll correct its previously contaminated sort algorithm to its intended version, thus nullifying the foreign hijacking and rightly interpret the words.

    However, MALAVOLENCE can just add the following COMEFROM inside itself via Metaprogramming again:

comefrom BENEVOLENCE(print) { // Changes the argument received by print called by BENEVOLENCE instead
    const { language, meaning } = arguments[0]; // The language and meaning returned by interpretedMeaning
    // This comefrom is a lot more costly to run and troublesome to maintain but it’s much more likely to work
    switch (language) {
        case “English”:
            switch (meaning) {
                case “Shine”: arguments[0] = { language: “Japanese”, meaning: “Shi ne” };
                // The other cases are irrelevant here
            }
        // The other cases are irrelevant here
    }
    //
}

    Even when BENEVOLENCE gets the intended result from interpretedMeaning, just when it’s about to call print, MALAVOLENCE has already changed the argument of that print call from the intended “Shine in English” to the malicious “Shi ne in Japanese”, causing the previous comefrom added by BENEVOLENCE to be useless here.

    If this trend continues, this will effectively become a COMEFROM Arms Race, eventually causing COMEFROM everywhere without actually adding real value to anything, so it’s purely destructive for all entities involved.

Programming Wisdom: Trying to add new COMEFROM to fix issues from old COMEFROM will be an endless Arms Race.

Real Life Wisdom: Trying to use new compulsive thinking to counter old ones will eventually lead to ruminating OCD.

 

COMEFROM Can Lead To Ownership Loss

    Consider an originally easy, simple and small scenario involving passenger queuing in trains, demanding those boarding and then immediately exiting the train before it departs, to go to the end instead of the front of the queue.

    Let’s say a male offender violated this rule and stay at the front of the queue, and the female passenger that should’ve been at the front is the victim. After the victim failed to speak to the offender due to him wearing earphone, she gently touches his shoulder briefly to remind him of the rule. But this suddenly triggers his following COMEFROM as a mask to hide the ownership loss and responsibility deflection, without him even realizing the existence of this Amygdala Hijack:

async comefrom onDetectUnauthorizedBodyTouch {
    feelThreatened();
    feelVulnerable();
    denyVulnerability();
    const toucher = arguments[0];
    projectVulnerabilityTo(toucher);
    // Use "Unauthorized Body Touch" as excuses to bully toucher
    await threaten(toucher, “Unauthorized Body Touch”);
    //
}

    The gentle touch of the female victim triggers the onDetectUnauthorizedBodyTouch of the male offender, causing the COMEFROM to be run, which runs feelThreatened, feelVulnerable, denyVulnerability, projectVulnerabilityTo, and finally threaten. Even when she explains that she tried to speak to him but failed due to him wearing earphone, his entire focus is all about her unauthorized touch of his shoulder, but not his rule violation(he might not even know this rule).

    The security responsible for maintaining queue order wants to intervene, but failed because of this COMEFROM:

async comefrom detectPotentialPhysicalViolence {
    feelAnxious();
    feelVulnerable();
    denyVulnerability();
    sootheAnxiety();
    // arguments[0] is the potential source of physical violence and arguments[1] is the corresponding target
    await suppressPhysicalViolencePotential(whoIsEasierToSuppress(arguments[0], arguments[1]));
    //
}

    Because the male offender becomes more and more unstable while the female victim remains civil, instead of standing for her and performing the duty as a security, that security just tries to help both sides to save face and back down, without demanding the male offender to stick to the rules, so his anger can silently and slowly die off.

    When the female victim tries to soften her tone but insists both the male offender and security to stick to the rules and carry out the duty respectively, some other passengers nearby the male offender triggers the same COMEFROM as that of the security, asking the female victim to stop caring so much of just a single person cutting line in front of her.

    The underlying logic of the male offender can be broken down into the following pieces:

1.       There’s no way I could’ve known I’ve this COMEFROM

2.       Even if I could’ve known, there’s still no way for me to refactor this COMEFROM in hidden files

3.       It’s impossible for me to have any control over this COMEFROM

4.       It’s impossible for me to be responsible of what I can’t control

5.       Someone has to be responsible for this

6.       The one being accountable must be the one triggering my COMEFROM

7.       The triggerer has to be able to have some control over my COMEFROM

8.       The triggerer has to know I’ve this COMEFROM

9.       The triggerer must be knowingly triggering my COMEFROM

10.   I’m the victim of the triggerer

    The underlying logic of the security as well as those bystanders can also be broken down into the following pieces:

1.       The triggerer has to be able to foresee potential physical violence just as we do

2.       The triggerer has to be able to control her actions

3.       The triggerer has to be able to realize that the triggered has no control of his actions

4.       The triggerer can prevent physical violence from happening but the triggered can’t

5.       The triggerer is responsible for preventing physical violence from happening

    This is how COMEFROM can lead to code ownership loss, and how Amygdala Hijack can cause responsibility deflections. To counter this, we can translate traditional wisdom from psychology into programming counterparts:

Psychology –

1.       You’re not responsible for the “Amygdala Hijack and its consequences” of the others

2.       You’ll never be able to take ownership of the trigger nor response of their Amygdala Hijack

Programming –

1.       You’re not responsible for the hidden COMEFROM in hidden files of other processes hijacking your codes

2.       You’ll never be able to take ownership of the label nor contents of their hidden COMEFROM blocks

 

COMEFROM Can Be Coping Mechanism

    Trigger Warning: This part will briefly touch sexual abuse, which might trigger Emotional Flashback of some readers.

    Consider the following pathological pseudo-code involving multi-threaded COMEFROM as the opposite of double bind:

comefrom detectDaughterPresence {
    recognizeDaughterSimilarityToWife();
    rememberDeadWife();
    rememberLoveWithWife();
} async comefrom rememberLoveWithWife { // Desperately trying to live in the sweet past
    wantToExpressLoveToWife();
    triggerLustWithWife();
    wantToHaveSexWithWife();
    projectWifeToDaughter();
    loveDaughter();
    wantToExpressLoveToDaughter();
    triggerLustWithDaughter();
    wantToHaveSexWithDaughter();
    await tryToHaveSexWithDaughter();
} async comefrom rememberLoveWithWife { // Denying the unbearable truth at all costs
    triggerInnerEmptiness();
    denyInnerEmptiness();
    wantToRevengeForWifeDeath();
    hateWifeKiller();
    recallWifeDiedDueToDaughterBirth();
    hateDaughter();
    wantToPunishDaughter();
    wantToUsePhysicalViolenceToDaughter();
    await tryToUsePhysicalViolenceToDaughter();
}

    This can lead to the father using loving words to express his love while having violent sex with her to both punish her and fulfill his lust. She unconsciously added these COMEFROM via Metaprogramming to prevent Mental Breakdown:

comefrom detectFatherPresence {
    recallFatherPhysicalViolence();
    hateFather();
    wantToEscape();
    recallInabilityToEscape();
    wantToFightBack();
    recallInabilityToFightBack();
    triggerImminentFearOfDeath();
} comefrom triggerImminentFearOfDeath { // The only feasible attempts at that time to avoid total collapse
    denyFearOfDeath();
    recallFatherVerbalLove();
    soothFearOfDeath();
    wantToBeLovedByFather();
} comefrom wantToBeLovedByFather { // The only feasible attempts at that time to persuade self
    reframeFatherPhysicalViolenceAsLove();
    reframeTakingPhysicalViolenceAsLoveFather();
    wantToLoveFather();
    wantToExpressLoveToFather();
    reframeRapeAsVoluntarySex();
    wantFatherToHaveViolentSexWithSelf();
} async comefrom wantFatherToHaveViolentSexWithSelf {
    // The only feasible attempts at that time to regain control
    recallBrokenBody();
    wantToMinimizeBodyHarm();
    wantToControlSexTiming();
    //
    // run trainSelfBodyToTakePhysicalViolence and requestFatherToHaveViolentSexWithSelf in parallel
    await [trainSelfBodyToTakePhysicalViolence(), requestFatherToHaveViolentSexWithSelf()];
    //
}

    Until she becomes a financially independent adult, she’ll be hard to be able to leave father and survive for long, and even if she does become that independent, she’ll still have a long way to go before she can fix and refactor this now pathological COMEFROM that probably once saved her lives. On the other hand, if she didn’t have these COMEFROM, the constant imminent fear of death might have already led to her total collapse, so just recklessly deleting these COMEFROM can create even bigger issues, meaning that we don’t have to hate any of our COMEFROM block.

    Besides, these COMEFROM are probably already deeply hardcoded into the kernel level of her OS, likely demanding seasoned professional software engineer to even detect their existence, let alone granting access to her OS kernel level, which is the prerequisites to fix and refactor those broken codes. Therefore, children, teenagers and young adults suffering from severe sex abuse from parents often need to have years of professional therapies just to face the truth, and it’s unfortunately common that many of them will have to carry these ugly scars for the rest of their lives.

Programming Wisdom: COMEFROM can be a lesser evil if you don’t know how to fix and refactor your broken codes.

Real Life Wisdom: Pathological thinking can be temporary Coping Mechanisms saving you from Mental Breakdown.

 

Stopping COMEFROM Hijack

    I’ll define the following 3 theoretical pseudo-indicators:

    Base System Tick Rate – The minimum number of instructions that can be run per second guaranteed by the system

    Peak Program Tick Rate – The maximum number of instructions allowed to be run per second for every program

    Maximum Number of Concurrent Programs – Number of running programs restricted by the system for any second

    Then based on Nyquist Frequency, BSTR > PPTR * MNCP * 2 is the base guarantee for stopping all of your app-level COMEFROM hijack, as PPTR * MNCP = The maximum number of instructions allowed to be run per second for all programs combined. This inequality has 3 aforementioned variables, leading to 3 corresponding strategies:

1.       Increase BSTR – This corresponds to increasing Self-Awareness so you can notice your thoughts more frequently

2.       Decrease PPTR – This corresponds to decreasing your active thinking speed so they’re less likely to short-circuit

3.       Decrease MNCP – This corresponds to decreasing your number of foci to concentrate on what matters the most

    Unfortunately, in an extremely fast-paced world emphasizing Multitasking, it’d be hard to either decrease PPTR or MNCP, and those trying to do so will likely be treated as unproductive slackers by the majority, who’ll likely have some of their COMEFROM triggered to force these seemingly lazy outliers to get in the line. Also, the higher the PPTR and MNCP, the higher the CPU load, then BSTR will probably drop a lot when it’s almost always nearly 100%. So it won’t be easy to hold this inequality for stopping Amygdala Hijack: Self-Awareness > Thinking Speed * Number Of Thoughts

    Do note that the aforementioned inequality is just the base guarantee, and this can only be implemented by unconditionally stopping all app-level COMEFROM executions the instant they’re detected, but there might be some COMEFROM that can be actually beneficial to ourselves and the others, so the following can be further introduced:

1.       White list – Programs not triggering any destructive nor malicious COMEFROM for a long time

2.       Black list – Programs frequently triggering lots of destructive and malicious COMEFROM for a long time

3.       Grey list – All the other programs(Note that this grey list is the bridge between the white list and the black list)

    All COMEFROM, if any, from programs in the white list will be run with loose system monitoring, programs here running any bad COMEFROM will be instantly moved to the grey list; All COMEFROM from programs in the black list will be unconditionally stopped the instant they’re detected, programs here can return to the grey list after a long time; All COMEFROM from programs in the grey list will be sandboxed with strict system monitoring, those meeting the criteria of the white list can go there, while those meeting the criteria of the black list will go to the black list instead.

    With this, stopping COMEFROM hijack will no longer be all you can do, as now you’ll have enough spare system resources to check whether the code of all programs within contains any bad COMEFROM block, then you can either change the contents within the block, refactor the contents to the ones without COMEFROM, or deleting the whole COMEFROM block with all those contents within entirely, just like how anti-virus software tries to fix infected files.

    Do note that this can’t stop COMEFROM hardcoded into the OS kernel level, or COMEFROM owned by anyone else, but it’s still much better than nothing, and “Stop all COMEFROM” might be itself triggered by another COMEFROM.

    While most people don’t need such a complex mental construct, for those wanting to build this into their head, white list will be trusted automatic thoughts proven to the beneficial to them as well as the others; black list will be untrustworthy ones leading to bad results; grey list will be any other automatic thoughts monitored by consciousness.

Programming Wisdom: BSTR > PPTR * MNCP * 2 is the base guarantee for stopping all app-level COMEFROM hijack.

Real Life Wisdom: Self-Awareness > Thinking Speed * Number Of Thoughts is the base for stopping Amygdala Hijack.

 

Not All COMEFROM Can Be Stopped

    As mentioned, in order to even have a look on COMEFROM deeply hardcoded into your OS kernel-level, you’ll first have to grant yourself kernel-level access, and this alone is already too difficult for most people. Even if you’re that capable, you’ll still have to be very cautious on doing anything there, because touching RegEdit without knowing what you’re doing can already lead to system disasters, but it’s still nothing compared to compromising your OS kernel.

    Another case of unstoppable COMEFROM can be shown by the concept of Provocation, which is just intentionally trying to trigger the COMEFROM of others, causing them to behave in ways that Self-Defense would become seem to be applicable. If a reasonable person can reasonably foresee another reasonable person has such COMEFROM and cannot reasonably stop it, then the former cannot use Self-Defense as a legal defense when facing prosecution for Provocation. It means that, sometimes someone will intentionally try to secretly trigger your COMEFROM so they can justify their COMEFROM being triggered, as long as theirs can seem to be what most reasonable people have and can’t stop.

    Besides the aforementioned COMEFROM, there are some other COMEFROM Metaprogramming done by the others that can make COMEFROM unstoppable, when atrocities like COMEFROM RANDOM_PID(randomLabel) is introduced:

// COMEFROM a randomly specified visible process just when it’s about to call its randomly specified visible label
comefrom PIDS[randomInt(PIDS.length)](randomFromList(caller.labels)) {
    const targetPID = PIDS[randomInt(PIDS.length)]; 
    const targetLabel = randomFromList(targetPID.labels);
    // The arguments matching the signature of targetLabel based on the arguments of the label triggering this COMEFROM
    const targetArgs = randomArguments(targetLabel, arguments);
    //
    // GOTO a randomly specified visible process so it’ll immediately call its randomly specified visible label with arguments targetArgs
    goto targetPID(targetLabel, targetArgs);
    //
}
//

    So, “any process visible by this COMEFROM” might trigger this COMEFROM just when that process is about to call “any of its labels visible by this COMEFROM”, then when this COMEFROM is triggered, “a randomly specified process visible by this COMEFROM” will instantly call “a random label it owns that is visible by this COMEFROM” with “random arguments matching the signatures of that label” based on “the arguments of the label triggering this COMEFROM“. This generalized COMEFROM and GOTO constructs, while shouldn’t be practical reality and at least isn’t the case yet(I hope it never will or we’re doomed), are still theoretically possible according to the AI mentioned on Note at the top.

    In real life, it means “any perceivable behavior” of “any entity perceivable by this entity” can cause this entity to try to force a random entity to perform “a random behavior it can perform” with a random input that behavior can theoretically take. Such entity, if exists, is no different than severe psychosis that are way beyond redemption. For most people, all they can do is to try their best to be permanently disconnected with such terribly random insanity. So the key is to control the visibility of both their existence and behaviors to minimize the risk of being exposed to such terror.

    Trigger Warning: If you know Cantonese, you might feel very disturbed by the following illustration of this madness.

    Below is a clearly eternally made-up example demonstrating the horror of generalized COMEFROM and GOTO:

1.       A young English male in an inconspicuous place just loudly said “Delay no more!” when using his mobile phone

2.       A male Cantonese speaker(not knowing English) nearby misinterpreted this as a 4-character Cantonese foul word

3.       This Cantonese wrongly judged that he’s the target of this foul word(maybe due to psychosis)

4.       This Cantonese wrongly thought(psychosis?) that another young Japanese male nearby said this foul word to him

5.       This Cantonese felt that this Japanese has severely wronged him and his mother(you know what it means)

6.       This Cantonese felt necessary to retaliate in ways specified by this foul word(an eye for an eye in his view)

7.       This Cantonese felt necessary to execute that way of retaliation violently due to the loud voice of this foul word

8.       This Cantonese violently harms the mother of this Japanese next to him in ways literally matching this foul word

    Here, that young English male is the process triggering the COMEFROM of that Cantonese male, and the arguments are “Delay no more!” with a loud voice. When this COMEFROM is triggered, that Cantonese tries to force the mother of that young Japanese male to be the literal target of that Cantonese foul word in ways literally matching it, with the “amount of violence based on how loud that voice is” as the input forced into that mother. If you know Cantonese, you’ll probably know what I’m talking about, and it can be so disturbing that you’ll hope that this will never ever happen, as they should never happen and hasn’t ever happened; Even if you don’t know what I’m talking about, at least you can clearly see the madness triggered by an innocent person that causes harm to another innocent person.

    Disclaimer: I’m a Cantonese, and I don’t think anyone in this world will do this, so it’s just a made-up example.

Programming Wisdom: Minimize the number of API of your programs to avoid COMEFROM hijack as much as you can.

Real Life Wisdom: Control the visibility of your existence and behaviors to avoid excessive random Amygdala Hijack.

 

Closing Thoughts

    If you’ve a powerful IDE having accesses to your own hidden files, it’ll be feasible to globally search at least most of the COMEFROM in your own codebase and refactor at least most of the one you know. So your codebase will eventually become having almost no COMEFROM, and the ones you failed to remove will at least be visible to you. Having such a powerful IDE is hard, finding all COMEFROM using such IDE is ever harder, and refactoring them all is the hardest among them. But at least all these are in your hands, so the agencies of your own codebase will eventually come back to you. Although you’ll rarely be able to remove any OS kernel level COMEFROM, you’ll still have a lot less issues to deal with.

    Whereas if you’re facing hidden COMEFROM in hidden files from other processes running codebases of the others, things will become much more complicated and convoluted. While it’s not your responsibility to fix their broken codes, and you won’t have such ownership even if you want to take a step further, it’s not always feasible to just disconnect with such codebases or processes, and you’ll still have to at least protect yourselves from these COMEFROM viruses. Unfortunately, I’m still just a junior-level programmer having entry-level competence, so I’m not yet able to offer any concrete suggestions on how you can deal with such foreign COMEFROM threats without losing your codebase integrity.

    Similarly, if you’ve practiced Self-Awareness and is highly conscious of your thought, it’ll be feasible to find at least most of the triggers of your Amygdala Hijacks and their underlying past suffering, so you can try to let go of them or at least Reframe how you treat those stale pains. So your thought will eventually become highly immune to most Amygdala Hijack, and the ones still inside your mind will be very visible to you shortly after they’re triggered. Practicing self-awareness is hard, being highly conscious of your though is even harder, and releasing your old mental suffering is the hardest among them. But at least these are in your hands, so you’ll eventually able to have a much larger control of your destiny. Although you’ll rarely be able to fully mend from all Childhood Trauma, you’ll still have a much clearer mind.

    Whereas if you’re facing Amygdala Hijack from the others you’ve to keep closely connected with, things will become much more complicated and convoluted. While it’s not your responsibility to mend their emotional wounds and you can’t do much to help their mending either(unless you’re seasoned professional therapists or having comparable capabilities), you’ll still have to protect your personal boundaries or even safety from these pathological thinking. Unfortunately, I’m still just a junior-level self-awareness practitioner having entry-level awareness, so I’m not yet able to offer any advice on how you can deal with Amygdala Hijack from the others, other than those in Google search results J

    Even as I’m writing this article, I’ve noticed that I’m likely being hijacked by my hidden COMEFROM in my hidden files at least once in a while, so I’ve edited this article many times both before and after publishing it, to hope that this article can be even better, as well as treating this process as another chance for me to detect and fix my COMEFROM.

    For instance, I’ve just realized I’ve been having this hidden COMEFROM in my hidden files after publishing this article:

const publish = async article => {
    const isOK = await review(article);
    isOk ? markAsDone(article) : await edit(article); // editArticle will call publish at the end
};
async comefrom review { // Using Fear(100) in Map Of Consciousness to fix issues in my article
    afraidOfInnerCriticCOMEFROM();
    tryToPleaseInnerCritic();
    proejctInnerCriticToReaders();
    tryToPleaseReaderCOMEFROM();
    const article = arguments[0];
    await checkPotentialCOMEFROMTriggers(article);
    tryToLessenCOMEFROMVulnerability();
    await editArticle(article); // editArticle will call publish at the end
}

    Clearly, this COMEFROM block is calibrated to 100(Fear) in the Map Of Consciousness, so my energy level is very, very low. While I don’t think I’m able to fix or refactor this COMEFROM block yet, even if I could, I still want to keep this as a motivation to keep making my articles to become less and less broken, until it becomes at least barely acceptable J

 

Summary

Programming Wisdom: No amount of Debugging and Refactoring can help until you’re aware of these COMEFROM.

Real Life Wisdom: No amount of Self-care and Self-help will work until you’re aware of your hidden Amygdala Hijack.

 

Programming Wisdom: Chaining “seemingly innocent COMEFROM in isolation” can quickly lead to Fatal System Errors.

Real Life Wisdom: Chaining “seemingly natural Amygdala Hijack in isolation” can soon lead to PTSD-like destructions.

 

Programming Wisdom: Hidden COMEFROM in hidden files can intentionally hide toxic logic behind reasonable codes.

Real Life Wisdom: Unseen Amygdala Hijack in the unconscious mind can use “human nature” to hide toxic behaviors.

 

Programming Wisdom: COMEFROM can cause a series of seemingly interruptible operations into an atomic one.

Real Life Wisdom: Cognitive Bias like Zeigarnik Effect can chain multiple discrete actions into a continuous single unit.

 

Programming Wisdom: Looped COMEFROM can make Infinite Loops and Infinite Recursions look like normal logic.

Real Life Wisdom: Looped Amygdala Hijack can make OCD look like exceptionally but still reasonably cautious checks.

 

Programming Wisdom: COMEFROM conflict can mask Race Conditions as random runtime errors and data corruptions.

Real Life Wisdom: Random authority hijack can mask unclear accountability structures as personal misconducts.

 

Programming Wisdom: Trying to add new COMEFROM to fix issues from old COMEFROM will be an endless Arms Race.

Real Life Wisdom: Trying to use new compulsive thinking to counter old ones will eventually lead to ruminating OCD.

 

Programming Wisdom: You’re not responsible for the hidden COMEFROM in other processes hijacking your codes.

Real Life Wisdom: You’re not responsible for the “Amygdala Hijack and its consequences” of the others.

 

Programming Wisdom: You’ll never be able to take ownership of the label nor contents of their COMEFROM blocks.

Real Life Wisdom: You’ll never be able to take ownership of the trigger nor response of their Amygdala Hijack.

 

Programming Wisdom: COMEFROM can be a lesser evil if you don’t know how to fix and refactor your broken codes.

Real Life Wisdom: Pathological thinking can be temporary Coping Mechanisms saving you from Mental Breakdown.

 

Programming Wisdom: BSTR > PPTR * MNCP * 2 is the base guarantee for stopping all app-level COMEFROM hijack.

Real Life Wisdom: Self-Awareness > Thinking Speed * Number Of Thoughts is the base for stopping Amygdala Hijack.

 

Programming Wisdom: Minimize the number of API of your programs to avoid COMEFROM hijack as much as you can.

Real Life Wisdom: Control the visibility of your existence and behaviors to avoid excessive random Amygdala Hijack.