“Blame” doesn’t replace “Pride of Craftsmanship”

I have been using Tower as my Git client lately, as trained by my programming team. I’m the old dog this time learning syntax and style guides from them (and hopefully they are listening and learning design patterns from me). While reviewing the Tendenci code recently one question that I asked was “Where are the comments? And when someone does comment, why do they not put their initials at the end?”

To this the response was:

“We don’t need to put our initials on things. Version control takes care of that and we can use the “blame” function to find out who did what on any given line.”

I said OK at the time. But it has been bugging me. I couldn’t quite put my finger on why it bothered me, but it did. Who can argue against accountability? I see the business value in assigning blame and using that to create a teachable moment.

Having programmed a large number of products over the years (MS Access anyone? VB 4? Ahhhh, good times.) I was taught that software should be “self healing.” The end user should NEVER see an error message. If the user sees an error, the programmer didn’t do their job or they were just sloppy.  There is a reason Select Case statements end in Else. There is a reason If statements have both an Else and an ElseIf option. There is a reason you trap errors.

Error trapping is not a science it is an art. And again, programming just isn’t for everyone like any other trade. But if you are gonna do it, then do it right. Less really is more in programming. I love the DRY principle in Python. Our process was one of complete accountability. You, the programmer, tested it first and when you took it live, there was no third party tester to fall back on. There was no tester to blame. No Linus security blanket. For years when developing Tendenci we didn’t even have a staging environment. When you play with live ammo you learn to pay attention. High stress? Sure. But much more profitable than cascading code through four different environments before it goes live.

Back to the blame game. I was taught starting in my first programming class in 1983 that putting your name in the comments, or initials as the case may be, was a way of saying

“I wrote this. I am proud of this code. There are no bugs in it. And I DEFY you to find a bug.”

This goes back to Basic, Fortran, Pascal and my mainframe days. The only time I didn’t use comments with my initials was when programming in Assembler and I think I should get a pass on that one, as hellish as it is an all.

Initials and comments were so serious that my professor my Freshman year of college would mock us saying that if we didn’t put our name in the comments he knew it was going to be C or B code at best, but definitely not A+ code. A+ coders are proud of simple clean code and they want credit for it. They comment it and put their name on it. Now to be fair, this particular prof did mark you down a letter grade if you didn’t comment your code so his statement was somewhat of a self fulfilling prophecy.

Pride. Ownership. Creators. These are very positive things. And that is why we put our initials in the comments on functions and classes we wrote. It was a way of saying “I am proud of this code.”

And that is a very different attitude than the source control “BLAME” function which is used mostly to say “you f’d this up.”

Blame and pride-of-craftsmanship are two very different things. That is why it bothers me so much I think. Maybe the world has changed and programming is taught like dodgeball – the less you do and the more you hide the less you might get blamed for something? I really don’t know.

I do know that I do not like the negative connotations of “blame.” Where is the joy if you can be blamed for stuff but never credited? Yes I like having the “blame” functionality. It is just a bummer to see a craft go from a positive to a negative feedback loop. I’m still thinking about that. I do know craftsmen and artists should be proud of their work. And I believe my programming team is proud of their work. I just don’t understand how we got from pride to blamesmanship-only when we could have both.

I know the pride aspect isn’t totally gone because GitHub prominently shows how many commits you have made and which projects you work on. Yet quantity is not quality, and clean programming can be subtly claimed with initials to indicate pride of ownership without relying solely on “blame.” It doesn’t all have to be negative. Programming is about creating. And creating things gives us meaning. Which is beautiful.

Like I said, I’m still thinking about this one. I’m probably missing something. Feel free to blame me if I got it wrong.