Avoid Working Alone

Dear new developer,

I suggest that the first job you take be the one with the highest learning potential, not the highest earning potential. (This post contrasts the two, in the context of entrepreneurship.) This can vary depending on your skills and needs, but I’ve seen over and over again that you learn more with one or more team members than you do alone. Other technical people working on the same problems, even if they are new as well, will elevate you.

They’ll bring a world of difference that you can learn from, including (but not limited to):

  • technical tools
  • approaches
  • understandings of the problem

As you work with them, try to understand where they are coming from and appreciate it, especially as it relates to solving the problem. Building this empathy for others is really really important.

Now, what can you do if you get hired and are the only technical person on staff (either as a contractor or employee)? Luckily, understanding others and building empathy doesn’t just work with developers, so you can work on that aspect, even though the problems and language may be a bit further from your comfort zone. As far as learning differences in technical tools, I suggest you join a meetup or an online community or both.

Sincerely,

Dan

Everyone, Including You, Has Something To Teach

Dear new developer,

I am happy and amazed when new developers help out other developers. I’ve seen several new folks go back and mentor at a bootcamp. Or present at a meetup. This is great, because everyone has something to teach.

You may think to yourself: “No! I am learning so much right now. I don’t know anything. There’s no way I could teach anyone something.”

False.

There are at least three ways you can teach something.

I will note that some people are less willing to learn from people they consider “new”, but some people have a hard time learning from anyone, for that matter. Always be aware that the first step in teaching is to teach in a way that the student can learn. That may be socratic, it may be by example, it may be by formal teaching methods. Also, it’s important to realize when you are just starting out that you are unlikely to have the full context for why a system or codebase got to where it is. Never trash code, even if others are doing this, because you just don’t know what constraints that code was written under. When I am new, I always couch my suggestions for improvement in terms of “This is what I think, based on my knowledge of the system. What do you [person who has been working on the system for longer] think?”

That said, here are valuable ways you can teach someone on your new team something.

  • Use your lack of experience to ask why things are a certain way. “I don’t understand” is a key phrase here. Questions like: why do you have only one server? Why are you using that language for data processing and this one for webdev? Why are we hosting git internally instead of using github? I always love when a new person starts at a company where I work because they are the antidote to the “fish in water” syndrome. Sometimes you live with systems for so long that you don’t remember why they evolved to where they are, and a new person can come in and cause you to re-think decisions. So by the simple act of asking questions, you are teaching others to re-evaluate the systems they may have become used to. Write down the answers.
  • Bring your new technology experience. “What do you think about trying XXX” is the key phrase for this tip. Chances are high that if you are a new developer you are trained up on new, popular technology, either through your schooling or through self study. (If not, this tip doesn’t apply.) New functional javascript frameworks, for example. Look to see where new technology or techniques may be helpful. Again, don’t proclaim “we should do it this way, this is how we did it at school”. That’s not helpful. But bringing your experience with newer ways of doing things is helpful. I met someone at a conference who worked with an old technology (Cold Fusion) but was introducing Test Driven Development for his own code, after discussing it with the team. This is a perfect example of someone bringing their own newer experience. The team may or not may be receptive, but that’s a different kind of problem.
  • Niche down. If you have the ability and the time, you can find areas of a codebase that are neglected and study them. You can ask other team members where poorly understood areas of the codebase are; the key phrase is “What parts of the code are scary?”. Try to really work through what is going on. (Bonus points if you write up tests.) Depending on the size and complexity of the code base, you may be able to in short order become an expert, or at least be ahead of anyone else. Then you can write up documentation to help other people understand this area.

Whenever you are new someplace it behooves you to be humble. You don’t know what you don’t know. But that doesn’t mean that you need to always be the student. Be delicate, ask questions, but realize you have something to teach as well as learn.

Sincerely,

Dan

What is HackerNews’ Best Advice to New Developers

Dear new developer,

I have previously written about joining an online tech community. My personal go to right now is Hacker News. I find it has a nice mix of tech, startup/business and other interesting content for me.

Here’s a thread from a few months ago with advice for junior developers. Here are a few of my favorite pieces of advice.

Lots more good stuff, including hundreds of other comments. Worth a read.

Sincerely,

Dan

Programming Is Terrible, So Learn To Enjoy It

Dear new developer,

I appreciated this post which talks to people who are interested in being a developer, rather than someone who is newly a developer. I still think a lot of things apply.

This especially resonated:

…programming is terrible, so learn to enjoy it. If you are “on the net” learning about what programming is like, listening to the voices that get the most attention, you are probably getting the “Hollywood version” of what it means to work with software day in and day out. Now don’t get me wrong, I love programming. My best days are when I can take off the many other hats I wear and just focus on a development project and writing tests to go with it. But, it’s not all roses, and you should be prepared for that.

Here are some things that are terrible about programming (and counterpoint).

  • The tool set is always changing. What you learned two years ago may or may not be useful to you now. But some technologies age better than others, and you always have a chance to learn something new.
  • There are two modes of development that are radically different (deep thinking and communication), and you have to switch between them constantly. But you get to do deep thinking!
  • Error messages don’t make sense. But Google can help with that. And so can you, by blogging about the error after you figure it out.
  • With modern applications, there’s a ton of complexity and you can’t possibly understand everything. But you can put together an amazing application that would have taken a team of developers by yourself or with a small team.
  • Sometimes, you may be the expert in your problem, which can make it hard to find help. I remember writhing on the floor trying to figure out one of the most difficult problems I’ve ever solved (figuring out an editing interface and rules for recurring events on a calendar with child events that needed to have different durations than the parent event) and realizing that I could ask no one about it. But, you get the chance to be an expert!

Of course, every job has its warts. And development is no different. But programming and development are in a rapid state of flux. This means that you must (and get to) learn every day.

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.

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.