Published 2025-12-10
tag(s): #random-thoughts #programming
I remember the first time I uploaded something to GitHub, in 2013 or so. I feared that I would write bad code without even realizing and someone would see it and I would be judged by the Python elders (at the time, I had just a couple years experience with Python, zero professionally). It literally took me effort to get the point of pushing the code up.
And then I was anxious about it. I am not being hyperbolic, literally anxious. But a few days later: nothing. Because GitHub is huge, my code was a drop in the ocean. I didn't overcome then my fear of writing "bad code", but I found comfort in knowing no one would read it if I did. Yay!
Fast forward to 2018. I joined a company, and many in the team had double the years of
experience I had. My very first PR went up, and the comments rolled in quickly. Some had to do
with the fact that I was new in the team, so "our ways" hadn't seeped into my
brain yet. But a few others were concerns with how I coded something, whether it was fast,
reliable, readable enough.
This happened to be my first job outside the company that sponsored my visa, which also meant
the first time working for an organization that didn't perceive me as a second class
citizen.[1]. My first time "in the wild": I wasn't hired because I
was cheap, or would put up with with the IE6 migration that no one else in the organization
would do. This was a group of people that saw some of my code, asked me a few questions, and
were happy to give me a chance to be in their team.
And my code was not up to their quality standards.
This is it, it is over. Time to return my green card and head back to Argentina. But I can't
code ever again! I know from my time in high school[2] that woodworking is
not my thing, but I did well with welding.[3] That's my future prospect, I
guess.
But before running away for ever...I had to clean up the code. Atone for my sins in
small fixes, comments explaining why this or the other, applying suggested changes that made
sense.
The next morning (or maybe next-next), one of the other guys submitted a PR. One of the wise
men. I looked over the code, unsure of my qualifications to provide feedback. I didn't add
anything.
I checked back the submission an hour later: lots of comments. Not unlike the ones I received.
And the tone of the conversation was exactly the same. Over those first two weeks I realized these people were very matter of fact about code. There were egos, none of us were perfect, of course. But pride of authorship always took a backseat to "team pride": all of us were better coders than any one of us. And if we someone else identified a possible improvement, and after discussion it was confirmed as such, it was implemented.
I don't think it took more than a couple more weeks for me to feel comfortable with
critiques of my code, and just a bit more to suggest changes myself.
And our little group developed a bit of a fame for delivering great products: extremely
stable, good performance, small repositories of highly curated code. I could see a direct
relation from this to our review process.
Around that time I wrote a bunch of Emacs packages to interact with tools that I used at
work. I was definitely not very proficient in (any) Lisp[4].
When I submitted the first of these packages to MELPA, as
customary, the code was reviewed and I had some changes to make before it was published.
And I felt...happy?
Because many of the things suggested were more idiomatic than what I wrote. I was learning!
I was on my way to becoming a better Lisper![5]
The change of attitude about receiving feedback, in about a year since my first review, didn't
register at the time.
But whenever the topic of reviews comes up, I tend to go back to the contrast in my feelings
on that first review at work, and the time someone I had never interacted with until
then critiqued what I was putting out there in the wild.
The topic of code reviews and feedback came up a few times in my current team - usually for unhappy reasons.
And in trying to understand the reticence of others to having their code reviewed and/or modified by someone else, I was thinking back to my own early struggles with "coding in the open". Like, how I went from feeling ashamed of someone reading anything I write, to having even the pages of this site in a public repository.
So, what was that initial shame? The impostor syndrome that crept on that first work review?
And I guess it was pride. Even if it sounds backwards: if you are so proud of something, then
why would you be ashamed to have others look at it?
But it makes sense, if you have a sense of ownership over your code (which is good, by the
way!) that you would feel maybe attacked by comments about it? Because it is like
they are attacking you?
I mentioned in another post that you want to have people that care about their code, so they
do a good job, but that no one should care "too much", because then they are open to
changes and feedback.
And maybe that wasn't right.
Maybe the ideal is aiming to replace the individual ego for a team ego:
recognizing that we are all in the same group, that any suggestions made are to improve "our"
output, and that reviews are a knowledge exchange. We all keep learning from each other.
Although, that wouldn't quite account for the "solo open source" case, like the MELPA review I mentioned before.
No conclusion, just putting some thoughts out there as I try to process that last exchange on
this topic.
My only immediate action right now is to try to be gentler when reviewing other people's code,
I guess. It is a slippery slope though, once you reach the point that everything is a
"gentle suggestion" rather than a "request" to revisit something.