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.
- Do I clearly understand the components at work and how they interact in the system in question?
- 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?
- Am I making assumptions that I haven’t been able to prove? Have I written any tests to prove these assumptions?
- 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?
- Have I taken time to write out my current questions and investigate them on my own?
- Have I asked relevant questions on our messaging medium — generally Slack — and taken time to investigate answers provided to me in this written medium?
- Have I taken a break, walked around, done some push-ups, absorbed some sunlight, and come back to this problem with fresh eyes?
- 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.
Letters To A New Developer 