Let’s face it, the road to becoming a better developer is neither an exciting nor smooth sailing one. Like many other craftsman-type skills, it demands discipline and is far from an effortless endeavor. After all, it takes about 10,000 hours of practice to achieve mastery, and even that is far from sufficient. If you’re like me, you’re desperate to progress past being a novice. Even so, finding the drive and determination to put time into our craft (outside of work) can be daunting because finding your own knowledge gaps isn’t straight forward. Don’t get me wrong, I love the thrill of wrangling code, but I admit to my own lack of sustained enthusiasm, especially when it fails to give me immediate gratification.
We live in a culture where immediacy is desired over long-term benefits. As unfortunate as it may be, our industry perpetuates this mindset. Developer bootcamps and coding intensives condense the process of learning to code into a 12-week curriculum and promise prospective customers/students the experience they need to successfully land a job. Though many of these programs have been put in place with good intentions and are arguably necessary to fill the developer shortage, they perpetuate a short-term mindset—learn fast and get the job done. In the process of becoming a better developer, however, there is no tangible end goal or any definitive way to measure progress. Even after hours of practice, the feeling of mediocrity remains.
With little progress to show, staying motivated through the learning journey is a challenge. However, by taking charge of your own learning, you can put yourself on the path to being a better developer. Here are a few pointers that I’ve learned in my own journey to become a stronger developer.
Experience the Process of Writing Code
One way to focus on being a more effective and motivated learner is by approaching it from an agile standpoint. Kathy Sierra talks about this as ‘Just-In-Time Learning’ in her book Badass: Making Users Awesome; “Just-In-Time means learning something only when/because you actually need to use it.” Too often, we fall into the mindset that we must first learn all the things before even attempting to write a single line of code. Instead of trying to learn everything “Just-in-Case,” which will only leave you feeling overwhelmed—break up your learning into smaller, manageable tasks. A perfect practice for Just-In-Time learning is simply to learn on the job or by giving yourself specific problems to solve via code katas. With very specific tasks to complete, you are thrown into situations where you seek out knowledge. When you learn through experiences, you are more likely to retain what you learn.
Personal projects are also ideal for giving your learning direction and allowing you to track your progress. They are hotbeds of learning and let you cut your teeth on a language or framework. When working on them, keep in mind that the main goal should always be about learning something new, however small that may be. If you’re interested in strengthening your knowledge of HTTP and figuring out how APIs work, then play around with making HTTP method calls in your terminal and see what is returned. If doing something of that nature is intimidating, start much smaller and work in a sandbox environment like JSBin or Codepen. In the event that you get stuck, don’t hesitate to seek out knowledge and help, but only after you have banged your head on it a couple of times. Part of being a better developer is knowing how and when to ask questions. Help and support can always be found via Free Node Channels, public Slack channels, and Stack Overflow. Starting to code independently builds your confidence and gives you opportunities to find and fill your own personal knowledge gaps. Just make sure you start and finish one thing today.
Share Early, Share Often
For someone new to the field, sharing your work with others can be a challenge. I too have had my fair share of insecurities with this. At the risk of sounding like a broken recorder, there is so much to gain from showing your code. Having your co-workers regularly review your code and inviting feedback and discussion is the best way to learn from mistakes and pick up on good code sense. If you’re currently on a dev team with a good version control or pair programming workflow, you’re probably already doing this. If you are not, there are many opportunities for you to share your code online and in-person via developer meetups and hack nights. Contrary to the popular stereotype, developers typically work on teams and liaise directly with clients and/or users. As a result, good communication skills and the ability to explain concepts to both technical and non-technical people are crucial to being an effective developer. Software is just as much soft skills as it is hard skills.
Seek Mentorship and Be an Active Mentee
When you’re surrounded by super talented mid- and senior-level people, it can feel extremely intimidating—and keeping up may be a challenge. Even so, as a junior developer, you have most to gain with so many people to mentor you in your journey. Mentors not only help you when you’re stuck on a difficult problem, they offer you insight to your own process and give you the tools and techniques that will help you get better. Sarah Mei wrote an amazing post about Pairing with Junior Developers that can be applied back to how junior developers relate to mentors. For one, when pairing with a more senior developer, be proactive and give them feedback about whether you understood something, need further clarification or if they’re not letting you drive enough. Having these conversations can be awkward, but that feedback is crucial to making sure you are getting the most out of your time with your mentor. It also serves to help your mentor be a more effective teacher.
Never Compare Someone’s Middle with Your Beginning
It took me a whole year before I felt comfortable calling myself a developer. It wasn’t imposter syndrome so much as my own insecurity about my inexperience—which is totally expected and normal for a new developer. Beating yourself up about not having started programming back when you were in diapers on a commodore 64 won’t get you anywhere and only serves to feed your own insecurities. A developer mentor of mine gave me this wonderful piece of advice in dealing with the frustration of being inexperienced.
“Let that frustration drive you… Your self-loathing can do only one of two things: paralyze you from accomplishing anything or push you to change. It’s very important that you let your frustration push you to change. Don’t let it paralyze you!
Also, don’t worry too much about what other people are accomplishing. Competing against yourself is a fulltime job—you won’t have time to worry about other’s success. You’re never too old, and it’s never too late.” —Neil Renicker
The Path to Becoming a Better Developer
“All that is gold does not glitter,
Not all those who wander are lost” —JRR Tolkein
While there is no real timeframe for the progression through the stages of mastery and competence in our industry, there is no real substitute for experience. Nothing can replicate the effects of sheer effort over time. That said, we all start somewhere. What is most important is that you actually start and keep yourself accountable to your own learning. There is no need to rush your progress; this is no race. By aiming for mastery in the short term, we are inevitably setting ourselves up for failure and unending disappointment. Focus on going deep in your learning and stay focused and on task. By applying these steps to your learning journey, you are well on your way to leveling up as a developer.