I’ve made a conscious effort to stop apologizing for bugs in my code

Alice and Bob are dating and plan to get married. They play a game in which they receive rewards for having the same answer to questions about their relationship.

They are asked: "Would it be preferable to serve ice-cream cake, or traditional cake at your wedding?"

Alice writes "ice-cream cake" secretly on her answer card, but Bob is still thinking.

After some thought, Bob writes "traditional cake" secretly on his answer card.

Both answer cards are revealed. The answer do not match, so the couple does not win a prize.

Alice criticizes Bob, "you should have known this, we love ice-cream, we had ice-cream on our first date!"

Bob believes he is not at fault. They argue. At one point Alice says "stop tying your identity to that question, just admit you made a mistake".

Bob still believes he is not at fault, and that he made no mistake, because it was never within his power to be certain what Alice had written on her card.

---

And now I ask: Is it within your power to be certain how the hardware and software of a modern computer will act?

My point is I will never be able to be certain that my code is bug free. That will never be within my power. I can only ensure that I follow a process that gives a good-enough probability that my code works correctly. What that process is, and what "good-enough" means, is largely determined by my company and team. I do follow that process, I do what is within my power. Should I apologize for not doing what was never within my power? Should Bob apologize for not doing what was never within his power?

I do accept the responsibility of ensuring "my code" (however the company wants to define it) is working well with the rest of the system now and in the future. Apologizing is completely orthogonal to accepting responsibility. Apologizing alone is not enough to "accept responsibility", and one can accept responsibility without apologizing.

PS - Alice and Bob eventually learned to avoid making moral judgments immediately in every situation.

Try working in military applications, aerospace, tax software, medical devices, banking. Making one mistakes can affect the fates of hundreds if not millions. It's way more responsibility and risk than the job you quote.

By the way. A dentist gets to try on fake tooth before drilling a real tooth. They actually don't have a choice, that's part of the mandatory training. Doctors gets to train on real people too, medicine schools go to great length to procure bodies for training purpose.

In programming, one would be lucky to get any sort of test environment.

Cognitive Behavioural Therapist (CBT) Dr David Burns has moved away from saying "sorry" to patients and clients who are upset by something during therapy sessions; he says apologising with "sorry" is such a problem because it's a too-easy meaningless platitude that people throw out without any thought and expect it to act to immediately silence the other person's upset without any further discussion, and the person on the receiving end of "sorry" knows this common use and expects it to be a cheap dismissive silencer which they can't respond to, so apologising isn't the same as accepting responsibility, apologising without accepting responsibility is dismissive and trivialising, accepting responsibility is better without it. That apologising doesn't add to understanding, it takes away from it.

Accepting responsibility is understanding the other person's reasons for hurting, which means listening to them.

Apologising is trying to make the other person to stop hurting, and stop them from talking anymore so you don't have to hear more or spend more time on it.

The though experiment illustrates that the same actions in different circumstances can have different results. What part of that assumes the only variable worth considering are the actions of the individual? The central point is that, as you say, whether or not we apologize depends on the circumstances.

I agree that you have to consider more than only the actions of the individual. I believe, if there is fault, it lies with not just one person, but also the circumstances. In cases where the circumstances are determined by management, company culture, legacy code, etc, the fault lies with many if not everyone. Thus, if one should apologize, then everyone should apologize.

While I agree with not "blaming" people for the mistake as if it's their fault as a person. I disagree with all of his reasoning and the action he choose not to do in this case.

I also take the position of "criticizing the idea/code, not the people" when it comes to other people's work. I rarely have a problem with criticizing myself.

Especially when it comes to "your" own code. You should be able to apologize for your mistake.

> It reinforces the idea that any one person or piece of code can be blamed for a given failure. Short of malice, this is never the case.

You can be attributed to your action. If you can be attributed to the good things in your work, then you can be attributed to bugs. Unless you are claiming that you have no control what so ever about how your code turns out, at which point, what are the different from you and a typewriter?

The thing is, you can be attributed for an instance of error. You can be blamed for the error you did. But you should never be categories as "the error".

> It gives the impression that, when you wrote the code, you should have written it better. This is a counterfactual that rarely holds up to examination.

Yes. There are instances that I could have written it better.

> It positions shame as the correct emotion to feel about bugs in your code: if you were a better engineer – a better teammate – the bug wouldn’t exist.

> If you’re a more senior engineer on your team, the effects of these anti-patterns are magnified: people see you apologizing for bugs, so they think that they should be striving to write bug-free code. They may feel ashamed if their code has bugs.

I take the approach and culture of "be strict with yourself but be kind to others". When I talks about other people's bug I always criticize the bugs itself and talks about problem and process in general without tying it to them. But when I talked about my code, I will also express what I could have done better or what is the pros and cons of my coding decision.

The thing is there's different between people striving to better themselves, and people blaming others for not being better.

You should strive to be better, while at the same times not being a snob or looking down on other for not being perfect.

In every day's life there's no permanently good people or bad people. There's bad action that people do. You should still be able to attribute a certain instance of event to a person. You just don't have to hold grudge and judge them forever based on it.

I am probably reaching it here, but I feel that the author is the kind of person that can't take criticism of his idea well because he feel that his idea is himself.

Your idea and action is yours. But your idea and action is not who you are. If you think it is yourself, then you become blindly defensive and either never acknowledge that you did it, like the author did, or never change.