Beware Of Your Arrogance

Dear new developer,

I wrote this post years ago, but it still applies today.

Ah, the arrogance of software developers. (I’m a software developer myself, so I figure I have carte blanche to take aim at the foibles of my profession.) Why, just the other day, I reviewed a legal document, and pointed out several places where I thought it could be improved (wording, some incorrect references, and whatnot). Now, why do I think that I have any business looking over a legal document (a real lawyer will check it over too)? Well, why shouldn’t I? I think that most developers have a couple of the characteristics/behaviors listed below, and that these can lead to such arrogance.

Just because you are good at something valuable (development) doesn’t mean that you are good at everything. I was blinded in my youth because I was good at asking questions, paid attention to details, and was good at creating logical constructs in my head. That is helpful in so many contexts.

But it is also true that almost every profession has as long, if not a longer, sense of history and as big, if not a bigger, well of knowledge than software development. So beware that your ability to probe, ask questions and solve problems doesn’t inadvertently (or worse, intentionally) dismiss the learning of other professions.

On the flip side, domain expertise (through lived experience or study) and software development is a powerful combination. You can model software such that end users can speak in the domain. You’ll be closer to understanding their problems.

Another issue with arrogance is that when you’re sure you know the answers (or have the right way to find them), you don’t listen to other people as well.

I was very happy to charge forward with whatever solution I thought made sense, and that led to suboptimal solutions. Both in the coding sense and in the sense that you have to bring people along. The best coded solution in the world won’t work if people won’t use it. So listen to your users and make sure you fully understand their worldview as best as you can before you charge ahead implementing solutions.

Sincerely,

Dan

Egoless programming

Dear new developer,

This post is worth reading in full, but is advice that holds for all developers, not just folks starting out.

I especially liked

Fight for what you believe, but gracefully accept defeat. Understand that sometimes your ideas will be overruled. Even if you do turn out to be right, don’t take revenge or say, “I told you so” more than a few times at most, and don’t make your dearly departed idea a martyr or rallying cry.

and

You are not your code. Remember that the entire point of a review is to find problems, and problems will be found. Don’t take it personally when one is uncovered.

But all of them are good. Go on, go read it.

Note that these principles (though not the post) are from a book published in 1971. Technology changes yet people remain the same.

Sincerely,

Dan

Work through the first month of trepidation

Dear new developer,

I remember the first month of my first job. I wasn’t sure who was who, what was what or even why was why. It was hard to find tasks that I felt helped the team. I wasn’t sure what words people used off-handedly meant. I’d read and re-read instructions, fearful that I wasn’t “doing it right.”

Every day was a struggle.

Eventually, I learned my way around. Around the code base. Around the organization. Around my tools. Around the team.

And everything got better.

And then I switched jobs and it happened again. The trepidation, I mean.

Yes, it was a bit easier, because I had previous experience to look back on. But I still needed to learn a ton to be effective at job #2. Eventually things got better.

And then I switched jobs and it happened again. The trepidation, I mean.

See a pattern? For every job I ever took, the first month was tough. You just don’t know, and worse, you don’t know what you don’t know. And even worse, you’ll often be hired into a company that is moving fast, so you may have a hard time finding someone to teach you.

There’s no easy solution, but there is a solution. Recognize that this will happen. Put your head down and do the work. Take one day at a time and celebrate your successes each time you leave work.

  • “Today, I learned how to deploy to our QA environment.”
  • “Today, I fixed two bugs and characterized a third.”
  • “Today, we were in a meeting and I made a meaningful comment.”
  • “Today, I figured out who the Docker experts are.”

And, soon enough, you’ll break through and find your way. Promise.

Sincerely,

Dan

Be a great developer today

This is a guest post from Tim Tyrrell. Enjoy.

Dear new developer,

New developers are making mistakes. They are making mistakes every day. As a new developer, one’s job is to recognize one’s mistakes, implement a change in behavior, and help others implement that same change when similar mistakes bubble to the surface of one’s awareness.

Software has clearly identified patterns. Observer, mediator, singleton, bridge, and abstract factory to name a few. Some patterns that are less popular include active mentoring, maximizing pairing interactions, and self-imposed code review. These patterns represent a few of the necessary actions required to fast-track one’s rise from junior to mid to senior and beyond. We are all guilty of exhibiting some of the best and worst behaviors as new developers— myself included.

Say Yes to Everything

This may seem daunting, but it will force a new developer to continue to claw at the boundary of their own comfort level.

They might ask: “How can I say yes to a task if I’m not sure if I can actually accomplish said task?”

Generally, software developer === problem solver. One isn’t required to know everything when one walks in the door, but one is expected to leave work each day having laid a few more bricks on top of an ever expanding foundation.

One way to level-up quickly is to say yes to tasks that managers either (a) do not have time for or (b) assign to test one’s level of grit and determination. This will show superiors that one has the bandwidth for complex assignments and that one is willing to accept challenges outside of the expected range. Time spent carrying out these tasks is less important than clearly communicating progress, outlining steps taken towards accomplishing the tasks, and reaching out frequently to resources at one’s disposal in order to avoid impasse.

Once a developer begins to set a precedence for clear communication, progress, and accomplishment, managers and senior developers begin to trust that developer at their word, and they take setbacks as a sign of high complexity or fluid acceptance criteria rather than a gap in skill-set or effort level.

Does one’s team participate in local developer meetups? Have they asked you to come along or give a talk on a project one recently completed?

Say yes.

Are one’s peers interested in a hack-a-thon this weekend?

Say yes.

Does a recruiter want to talk to the new developer about a position that might be a good fit?

Say yes.

Not that interested in the position?

Say yes.

Not that interested in the company?

Say yes.

Interviewing is a skill that needs to be practiced like any other to achieve mastery. Better to improve this skill before one is in need of utilizing said skill.

Do Not Waste the Time of Senior Developers

Developer time is consequential and incredibly expensive. When a developer with more seniority takes the time to pair with a junior they are undoubtedly losing time they could be spending doing a number of other tasks that are all vital to the health of their team. Before asking for this highly valuable time, I encourage new developers to ask themselves a few questions.

  1. Do I clearly understand the components at work and how they interact in the system in question?
  2. Have I spent ample time reading about the nuances of my problem on Github, StackOverflow, Medium, and other outlets? Did I google my error message?
  3. Am I making assumptions that I haven’t been able to prove? Have I written any tests to prove these assumptions?
  4. Have I replicated my issue multiple times, so that I can clearly outline my process when the time comes to explain it to the senior?
  5. Have I taken time to write out my current questions and investigate them on my own?
  6. Have I asked relevant questions on our messaging medium — generally Slack — and taken time to investigate answers provided to me in this written medium?
  7. Have I taken a break, walked around, done some push-ups, absorbed some sunlight, and come back to this problem with fresh eyes?
  8. Have I clearly identified the gaps in my knowledge and exhausted all other resources on my quest to fill these gaps?

Each of these questions probably deserves its own article, but developers — myself included — have ceaseless amounts of work to do and a limited number of hours in the day.

One must understand how the pieces of the puzzle fit together and communicate at their synapses. What is each piece’s objective? Is it doing too much? Have I identified the failure down to the line number?

Do this before asking a senior for their time.

All of the previous questions lead us to researching our problem on the internet. If we are not first googling the error message and reading about prior encounters, then we can certainly improve our debugging process by doing so.

Do this before asking a senior for their time.

Assumptions have plagued me mightily in my first few years as a developer. They have been at the center of many of my mistakes. Writing tests represents a fantastic way to test assumptions at a fundamental level of input and output of specific methods. If one’s team doesn’t have any tests around the components one is interacting with, then add them. If one does have tests, then run them and use them to help step through the code and check the data at each intersection.

Do this before asking a senior for their time.

We must make sure we can clearly replicate behavior numerous times or at least replicate inconsistent behavior until it becomes inconsistent. If the process is large and requires many steps then start writing them down. It is possible that one’s process is the problem. This feeds back into avoiding assumptions. Do this to ensure that the maximum amount of time can be spent analyzing the problem in question instead of searching for the unknown problem.

Do this before asking a senior for their time.

Don’t ever be afraid to ask questions. But ask them in an order similar to this: 1. Ask the internet. 2. Ask oneself. 3. Ask the internet again. 4. Ask a developer that worked on the code most recently. 5. Ask in the team messaging channel dedicated to questions.

Do this before asking a senior for their time.

Get up from one’s desk. Go for a walk. Talk to other developers near the water cooler. Don’t stare mindlessly at a screen during this time.

Do this before asking a senior for their time.

Check and make sure steps one through seven above have been carried out. Still have questions? Go ahead and make sure that one can clearly articulate every step in the process necessary to explain the problem at hand.

Now, and only now, should one ask a senior for their time.

Be On Time and Be Present

Every meeting, event, stand-up, or retro takes up precious developer time. It’s a new developer’s job to gather the maximum amount of information available, ask questions to clear up confusion, and add input where they have it. If a new developer shows up late then that developer is a disruption instead of an addition.

Let me tell all new developers a secret; they aren’t valuable enough to be distractions. Don’t be one — ever.

Use these meetings to show initiative and communicate clearly. Do not allow one’s distractions to eventually become a nuisance for other team members. Eliminate distractions and engage completely with the team and with the current discussion.

Engage Fully in Code Review

This begins with reviewing one’s own code with precision, accuracy, and a level of criticism reserved only for oneself. Where did one make trade-offs? Comment on that line and explain why the code was implemented in this way. Where did the new developer choose performance over readability?

Start the conversation.

Own the work.

Explain why.

If one isn’t aware of the why around these decisions yet, then be prepared to be taken to school by the senior developers until one does understand.

When the new developer code reviews their own work then they once again save time for those spending their precious attention and finite cognitive energy reviewing that code in the future. Follow conventions. Check that one’s CI/CD build passed. Do not ever ask for the time of other developers without a thorough pass through from oneself.

Add a video to the PR that show’s the functionality that has been developed. Show one’s test suite running. Show the level of detail needed to be a great developer.

Review the team’s pull requests. Ask questions about code that doesn’t make sense, but not before asking the internet.

Ask about patterns.

Ask about performance.

Ask about refactoring.

Ask about trade-offs.

Ask about testing.

Ask about anything that doesn’t look like it’s been written with the utmost care. This will push one’s teammates to improve and iterate upon their work, and they will thank one for it as they level-up.

Start Mentoring

“But Tim, I’m the one that’s new here. I need more mentors! Not the other way around.”

The above statement represents a faulty mindset within many new developers. One of the most efficient ways to solidify one’s skills as a new developer is to explain known skills to others who have yet to master them. This leads to personal mastery of the subject being taught. The subject can be related to environment, shortcuts, workflow, data types, performance, logic, tools, and just about anything else.

I guarantee the foundation of a new developer’s knowledge includes skills that even seniors do not possess. Share these skills with fellow new developers and expand both network and knowledge within this process.

Did one go to a boot-camp or university to acquire one’s skills? Go mentor students.

Spend at least an hour a week doing this.

Is one in a boot-camp or university currently? Mentor more junior students.

Spend at least an hour a week doing this.

Is there anyone more junior or at a similar level — within a year — of experience at one’s current workplace? Pair with that person and offer them one’s help whenever they ask for it.

Spend at least an hour a week doing this.

Giving back will not only help a new developer achieve mastery and network expansion, but it will also help them experience happiness via altruism. This type of happiness compounds over time, and it will lead to fulfillment one never imagined.

Start Making Changes Today

Don’t wait to be a great developer. Be a great developer today. Then be a better developer tomorrow. Then share the secrets of success with other new developers.

Imagine the world that we can build together with this mindset.

Please reach out to me personally if I can help with one’s developer journey.

Be kind.

Learn hard.

Do good.

Repeat.

– Tim

This post was first published on Medium.

Tim Tyrrell is a Software Engineer at Crownpeak and Current Mentor and Mod-0 TA at Turing School. He is also a Game of Thrones conspiracy theory enthusiast/Repulsed by Flat Earth conspiracy theorists/Pun loving guy/Helper of people willing to put in the work.

Work for a place where people care

Dear new developer,

Every company has its warts (aka issues, aka problems). I have never met anyone who worked for the perfect company.

So, go in with your eyes wide open and choose what warts your company has. You may be able to help fix some of them, but some will be permanent.

One wart to avoid: an indifferent team. One just punching the clock, trying to get through the day.

If a company is full of people who don’t care, then you’ll have trouble fixing any other issue. Customers will be an after thought. And work will drag. (Yes, places like this exist.)

That’s not to say that a place where people care will be unicorns and roses, but at least people will want to fix issues and serve customers well.

How can you tell from the outside if people don’t care? Ask questions like “how do you improve processes” or “what do customers love about what you do” or “what changes have you all struggled with over the past year” or “how do you keep up to speed on the newest technology”. If the answers to these indicate a lack of caring and empathy, then I’d shy away from that place of work. If you are already in it, make plans to leave.

Sincerely,

Dan

PS You also want to avoid people who don’t care.

It will turn out mostly fine… if you have the passion

This is a guest post from Jenn Chu. Enjoy.

‘Passion is one great force that unleashes creativity, because if you’re passionate about something, then you’re more willing to take risks’
~Yo-Yo Ma

Dear new developer,

I’ve always taken the quote above to heart… fast-shooting myself into the named camp of ‘Career Switchers` when talking about entry into the world of development. I’ve majored in Mechanical Engineer, spent 10 years in the Oil Industry, and just the last year and a half, really immersed myself into development.

I started at a Bootcamp part-time, got the certificate, quit my job, moved to a new city, worked as a Bootcamp TA and then finally landed my first job as an Associate Developer. It definitely wasn’t an easy journey, but I was passionate about this new life decision and I became obsessed. If not for the passion that led to a slight obsession, it would have been 10x harder to get to where I am.

For a new developer starting out, I’d love to tell you that it will turn out just fine… it mostly does… if you are passionate and have the drive. Learning new technology is not the only thing you should do to give you the edge. You must also go out, meet people, network, make projects, breathe… and then repeat. Learn the technology by finding out how it works more so than just watching tutorials. Meet the community and find coding and project buddies. Make projects for ideas to improve your life, or the life of others.

What I found most helpful in this whole process is having a mentor. Find a like-minded individual that is genuine and genuinely wants to be invested in your new journey. There is so much experience and knowledge that can be shared between both individuals, it truly is a beneficial experience for all involved.

Again, never stop learning, doing, networking and above all, doing what you do, what you are passionate about. The light at the end of the tunnel starts to get brighter and brighter with each passing day, have faith and take the risks! Life is too short otherwise.

– Jenn

Jenn Chu is a software Developer passionate about good design and building simple solutions that will enhance the end user’s experience. She is most excited to bring the diverse community together through collaboration, communication, and connections.