Rayhem

Fun fact: the original was only produced in English but the Shrek remix (which is a *BOP*) got translated into every language the movie did.

The physics prof who gave me my start would always get this kind of fond, nostalgic look in his eye whenever anyone mentioned "the days of punch card programming". So, naturally, I took an old slide rule and mounted it in a shadowbox with lettering that said "IN CASE OF EMERGENCY BREAK GLASS" when I got ready to graduate. He got a tremendous kick out of it.

Disclaimer: I'm just an...interested layman, but as far as I know we don't really know. It looks like there's both genetic and environmental components to it; your genes have a big impact on your "temperament" and more volatile temperaments correlate more strongly with cluster B disorders. But it seems like neglect, a failure to recognize a child as their own independent person (basically "my needs are your needs"), from parents/caregivers who are often themselves narcissists contributes pretty strongly, too.

The Little Shaman[1] has been one of the most comprehensive-yet-approachable resources I've found for understanding these kinds of high-conflict personalities. In particular [2-4] are pretty relevant to your question.

[1]: https://www.youtube.com/@thelittleshamanhealing/videos [2]: https://www.youtube.com/watch?v=uJZeXxU7QTg [3]: https://www.youtube.com/watch?v=TokWBgMQIZ4 [4]: https://www.youtube.com/watch?v=e5Hq_xNxrOg

> I came across narcissism. The idea that you’re smarter than everyone else. Comes from a grandiose sense of self importance.

This may be the colloquial description of how narcissism manifests, but it isn't even close to (and possibly completely opposite) clinical narcissism. The grandiosity isn't so much a belief as it is a "false self" put on to garner caretaking from others. It's not "I got all the toys as a kid, so I deserve more stuff!" but a failure to individuate from caregivers. "Mom (as a tool, not a wholly independent person) came when I cried as a kid, so I need you to lavish attention on me and make me feel better now as an adult. I can't see myself without external input; I only see myself as a reflection through you."

While claiming an aversion to being evil. Actions matter more than words.

Yes, exactly. If you have to update everyone's health (you do) and the updates are pretty much the same (they are), then things don't get any more cache friendly than this.

Sure. If your monsters have health, then their health is going to need updating pretty much by definition. Option 1 would be to make each entity responsible for updating itself with an overloaded `update` function in sort of a "classical OOP" fashion:

    for(auto &entity: entities) {
        entity.update();
    }

You're then responsible for weaving the health changes into your update (or getting it from your parent). Weird stuff can happen if one entity updates before another, too: you likely want all of the health updates to occur after all of the damaging events. So now this update function has to register a deferred health update to occur down the line.

Option 2 with something like an Entity-Component-System design would have a "Health" system that handles health updates across the board.

    for(auto &damageEntity: entitiesThatDoDamage) {
        damageEntity.registerDamage();
    }

    for(auto &healthEntity: entitiesWithHealth) {
        healthEntity.updateHealth();
    }

Neither of these options is strictly better than the other. Option 1 is good if you need a lot of bespoke logic for health updates (dragons update differently from humans which are different from vehicles etc.). Option 2 is better if everyone has `newHealth = oldHealth - damage`. Things are generally more similar than they are different, so you end up changing all values of a single "kind" (structures-of-arrays) more often.

If you're really accessing those fields it's overwhelmingly likely that you're accessing the same field for all of your instances. Your access pattern is going to be

    monsters[0].health = //calculation
    monsters[1].health = //calculation
    monsters[2].health = //calculation

and not

    monsters[0].health = //calculation
    monsters[1].name = //update
    monsters[2].is_poisoned = //check

Striding over your monsters array means you have to load each monster to access one field which just blows your cache to hell. Much better is to pack all of your health values together in a structures-of-arrays layout as opposed to the usual arrays-of-structures approach here. Entity-component-system architectures are a brilliant tool for managing this with some pretty performant results.

> The health of a monster is currently represented by a 4 byte signed integer, meaning that the health can range from -2^31 to 2^31-1 (2^31 ~= 2 million). We can already see that half of the integers potential is unused because the health of a monster should never be negative, so an unsigned int would fit way better.

If you're strictly optimizing for memory size out of necessity, then yes. It's dangerous to use an unsigned type in any context where you might even consider subtraction, though, and it's pretty effortless to see that new_health = health - damage is going to be used somewhere. Congrats! Your 100hp lvl3 monster just got resurrected with sixteen thousand hp.

> Sometimes authors use it without thinking, but removing the passive voice often makes writing shorter and clearer.

I don't think mentioning "authors" is absolutely necessary, but I think this is both a faithful attempt to convert this to natural active voice and easier to read/understand.

In the same vein, I've been keen to try out "What would the world look like if..." and then show that we do or do not observe related phenomena. It seems like the best way to meet someone on their terms (because they get to write the "rules" of the world) and then you just apply them towards one conclusion or another. But I haven't had enough exposure to really test this out.

Except when LLM providers bury the thing you're obviously looking for under an entire page of sponsored ads (buy Diet Coke™!), then that convenience argument starts to not hold up as well...

I had a parallel thought when a loved one was in the hospital. I noticed the nurses were so busy that small requests like an extra blanket were often forgotten entirely. How incredible would it be to have a voice system that would build a task list and capture other notable bits of information that the hospital staff could review on an integrated device (like a phone)?

Sadly, I don't see this ever happening due to the insane number of regulations you'd have to satisfy and the major players in this space only doing it to collect PII.

I've come to understand that software has two axes: the problem domain and the software domain.

The problem domain is things like your physical model. Your 3d mesh. Financial transactions. All things that need to be represented in software.

The software domain is things like components and queries. Things you can build in-software to realize your problem domain on a computer.

Defining a component and the behaviors of a component has nothing at all to do with the problem domain; it's purely an artifact of software to make your system more extensible/reliable/faster/whatever. But this is the part that's OOP excels at because you get to write the rules of your component taxonomy in its entirety. You have a ThingDoer class that can accept any number of Components to give it the behaviors you need, and then you start writing out components to model your problem domain. The objects and their behaviors remain at the level of "how do I put these pieces together". OOP sucks for the problem domain, though, because you're always stuck trying to munge some limited inheritance tree (animal <- dog <- wolf) onto the Real World and it's always going to miss something. Far better to build atomic building blocks that are expressive enough to compose into whatever you need.

Obligatory callout to Nick Trefethen (et. al.)'s Chebfun[1] which extends this stuff in just about every direction you can think of. 'Chebfuns' are to functions as floats are to actual mathematical numbers. It's some seriously impressive software.

[1]: https://www.chebfun.org

When it works we call it intuition. When it doesn't we call it superstition. There are all sorts of availability biases at work here; none of which really support the use of intuition as a valuable, predictive resource. After all, if your intuition fails to predict something, there must be some lurking variable somewhere that you failed to account for. Not that the intuition is wrong /s.

A/C is interesting because it has something of a built-in capacity system. "Super" cool the building during times of the day when power is readily available, and that cooling then persists. You don't have to store the electrical power specifically.

> "here's what you should have prepared for our 1:1s"

Tangentially, I'd like to survey attitudes about this kind of 1:1. I'm of the opinion that my 1:1 with my manager is my time to discuss my thoughts and needs. If a manager is assigning me homework so I can "come prepared" for yet another status update, they can sacrifice their time to make that meeting happen.

> If you have a laser, you can print an optical neural network using a consumer 3D printer.

I would love to look into this more. Do you have a reference that would give some instructions on how to give this a go?

Not necessarily. If self-driving cars "aren't ready" and then you redefine what ready is, you've absolutely got your thumb on the scale of measuring progress.

I would be very interested in seeing an error comparison of this technique against something like a full-wave PDE or integral equation solver. Demonstrating that the (fast) raytracing solution converges on the (slow) full-wave solution as e.g. the number of rays goes up is a very powerful statement.

Why not simply ask?

"Hi $COLLEAGUE. I'm having a problem with $TASK: I'm trying to accomplish $GOAL but I keep seeing $ERROR. I've tried $WORKAROUNDS, but none of them have fixed the problem. I think it will be fastest if I can demo this for you; do you have 10 minutes so I can walk you through it interactively?"

This sounds like the next-gen version of Translation Party[1]. The "translation equilibrium" is when you get the same thing on both sides of the translation. I wonder what the "AI equilibrium" is.

[1]: https://www.translationparty.com/

> I have no doubt quantum physicists know what they are talking about but...I always think it is the kind of excuse a schoolkid would give their teachers for their calculations being wrong.

Just to emphasize how extreme this dichotomy is, not only is quantum mechanics correct (in that it's a predictive model), it's the most correct physical theory humans have ever devised in that the measurements there have more significant figures than anything else.

> A better way to make decisions in a software project is to consult with stakeholders (if necessary), identify the appropriate decision maker based on competence and then let that person make a decision.

Holy shit. This is one of the most profound things I've read about management in a long, long time.

You can advocate for more personal responsibility and also advocate for businesses to behave in the interests of individual human beings. They're not mutually exclusive. Just because I don't want a business to extort every last cent from me they can doesn't mean I want to absolve myself of all responsibility to everything ever.

> Review your bank/credit accounts

I mean, shouldn't it be your responsibility to know exactly how much money you've made and spent? Why should a bank provide this information for you? Does this not serve as yet another lessening of personal accountability (pun *absolutely* intended)?

Perfect example of Betteridge's law of headlines[1].

[1]: https://en.wikipedia.org/wiki/Betteridge%27s_law_of_headline...

> This being a hobby project may also be a reason why the other programmers want to do things right; they may get satisfaction and learn new things by doing it this way!

Exactly my thought. Hobby projects are great opportunities to practice those skills since, if you don't, they don't manifest.

This is an incredibly myopic take bordering on arrogance. The infotainment system of a vehicle needs (as in, is mandated) to be as safety compliant as the rest of the vehicle's software so your steering doesn't lock out when the display crashes. Writing software for safety critical systems is not a task most developers are familiar with.

"Private sign, DO NOT READ"