My Algebra I teacher had a poster in the back of her classroom: “People who think they know everything really annoy those of us who do.” I loved that poster. And that class. Mrs. Meyers, the teacher, was good at her job. And she was very smart. And she knew it. But she didn’t lord it over anyone — in spite of the message that poster might proclaim.
I was the nerdy, super-smart kid throughout school. Learning came easy. I also liked that other people knew how smart I was. I enjoyed getting good — and often very good — grades. I didn’t mind “breaking the curve” (after we learned what it meant to “grade on a curve”).
At the time, I didn’t know that that attitude would shape how I worked with others. But it did.
Of course, being both smart and making sure that folks knew it meant that I wasn’t terribly popular either. I often received snide comments or was the butt of some very mean jokes. And I kept on being me because I had a few really good friends (who happened to be just as smart, nerdy, and weird), and I knew that I was going to continue doing well in school and in life.
I don’t remember when my attitude changed. There was no “Aha!” moment. Nor is there a juicy, embarrassing story of how the smart-aleck kid got his comeuppance. But I can tell you this: That’s not me any longer.
My growth definitely came from working with people who are way smarter than I am. Throughout my career I have worked with true geniuses — mostly software developers and architects who can look at a problem, think about it for a few minutes, then start to design a practically flawless solution.
But it also came from people who didn’t know as many facts as I might, or who didn’t understand software and technology like I do. I learned that many of them had a lot to teach me about life. How to enjoy the little things. How to laugh and how to cry. How to look in wonder at the Universe and realize that none of us actually does Know It All. How to be a happy, well-rounded human being.
In reflection, I realize that this was me learning to become a humble person: Being grateful for the skills, knowledge, and wisdom I’ve gained — while recognizing that others have depths I can’t begin to fathom. And to be willing to stand side-by-side with them as we work on a project, sit on a committee, or just navigate this thing called Life.
But what does this have to do with software quality?
You’re probably wondering why this post exists here among my professional writings rather than in my more personal, reflective writings on jaynewlin.me. The answer is simple, and I hint at it at the end of Three Sets of Eyes: I believe that software is best developed in teams, not by individuals.
And teams work best when everyone engages honestly, openly, and with humility.
No one person brings all the skills and knowledge that quality software requires. You might be a great developer but only so-so at making the UX/UI shine like it should. I’m good at testing and managing other testers, but if I’m writing code, everyone nearby should stop what they’re doing and wonder how the world went so sideways that Jay Is Coding.
I have also seen another important model of humility in several great teams: Leads and senior developers or architects who are able to seek, acknowledge, and praise the ideas and input of those who are more junior. Did code review reveal some intricate logic that a junior coded eloquently? Let them know how well they did! Encourage code review by someone who is junior to you: They very well may have recently learned a helpful pattern that you don’t know or have forgotten that can be applied to your current pull/merge request.
That’s what real leadership looks like. And the same is true for project managers and designers and business analysts: Recognize each other’s strengths and skills, celebrate, and benefit from them.
At its best, software development is a team sport, not an individual endeavor. Quality doesn’t come from any one person. It emerges from teams that are as committed to each other as they are to the work.