Blog   Home

Gracefully Handling Newness: Tips for Software Developers

philosophy · novelty · soft skills · learning

Author’s note: Inspired by my own recent experience of handling a lot of “newness” all at once, I started writing this blog. While writing it, I realized I was really just writing about my own philosophies on being a developer in general, because so much of what we do involves constant exposure to new ideas and tools. No matter where you are in your career, I hope there’s something here to inspire you to learn, grow, and participate in supportive developer communities.

scrabble pieces

As a software engineer, I find my self torn between two seemingly opposite goals: becoming a master of the skills that I already have and also constantly trying to learn new things. And I’m definitely not alone.

There is some comfort (and a lot of satisfaction) in mastering a subject and having the confidence to tackle any task within your wheelhouse. But equally as satisfying (in different ways) is trading in your “master hat” for your “I’m completely new at this hat”, soaking in novel information, and learning a new skill from the ground up. Deep diving into something new, though rewarding and sometimes necessary, can be very challenging.

Sharing a personal example: I had become very comfortable in my web development stack: React/Redux/TypeScript. At the beginning of the year, I became the primary developer on a greenfield project with all new-to-me technology: speech-to-text APIs, Unity, Magic Leap. This was a very exciting opportunity for me, but it also came with it’s fair share of challenges.

Along the way, I obviously learned a lot about developing in Unity, programming C#, and working with cutting-edge hardware (Magic Leap One). But I also learned some valuable lessons about how to handle that level of novelty. Here are some tips for handling these challenges gracefully.

Mindset

A huge part of tackling any challenge is mindset. Some people are naturally drawn to trying new things, while other’s prefer to stick to their comfort zones. But things are always changing in software, and learning to love newness and being able to roll with changes will serve you well as a programmer. Here are a couple of things I found helpful to keep in mind while cutting my teeth on several technologies all at once.

be positive

Be grateful for this opportunity

Even if trying something new doesn’t immediately excite you in and of itself, there are a number of ways it will pay off. Appreciate the opportunity to learn something new, grow your skills, and become an more versatile team member. Think of these challenges as an investment in yourself and your resume.

A change in pace can be good

While entering new territory, your pace may slow dramatically from your normal work flow. Working in Unity/C# for the first time, it was taking me days to create features that would have taken me hours in TypeScript. Which honestly sucks, but there’s lemonade to be made from those lemons.

It was very humbling, which I think is an important part of the personal and professional growth cycle. It helps you remember your roots (we all started from somewhere), and make you more empathetic to new developers. A slower pace can also create more room for reflection and break-taking, which are healthy.

Perseverance

Giving up is easy. Remember why you wanted to learn this technology and what value learning it can offer. Always reach out for help when you hit a roadblock. Most major technologies have channels for communication, Stack Overflow, or you can use this opportunity to go to a meetup and network with people who can help support you as you learn something new.

Creating a Solid Foundation

When getting started with something new, try to gain a solid foundation before advancing. This may go without saying, but sometimes our developer prowess can make us forget that. When working in my Unity/Magic Leap/Speech API project, I was tempted to learn all these technologies at once while starting to build the app. In fact, that’s how I originally started. However, I quickly realized that was not going to be a suitable way to learn or build the app. I was trying to start at level 5, but I hadn’t completed level 1 yet.

Make sure to take the time to practice before jumping into a major project. Once you’ve completed a couple tutorials, start by integrating the technology into a practice project. The classic example, of course, being a todo list app. If the thought of making another todo list app makes your heart hurt, there are plenty of other options.

If you have a personal project, try adding a new feature or refactor what you have using new technology. Even if this spike never gets merged to production, this helps you keep your personal project alive, gives you extra incentive to keep adding features and helps you practice new things all at once. If you don’t have a personal project going, what an excellent time to start one!

Remember: The real value in refactoring existing logic or making another todo list app is that you don’t have to worry about doing any logic design (because it’s already done), you just get to jump in to applying the new tech.

Depending on the technology or your general experience, getting in the practice could take a few hours, days, or weeks. So it’s important to be efficient with your time. Creating a practice plan with time boxed benchmarks can be helpful.

For example (totally hypothetical): I am going to spend 5 hours creating a Unity todo list app with state management. Once I have an understanding of Unity, I’m going to spend 6 hours retrofitting my Unity todo list app to run on the Magic Leap. By the end of the week, I’ll add a speech recognition API to the app for adding new items. Things may end up taking more or less time than you expect, but it’s good to have a plan.

Engaging the Community

Some of us prefer to take the lone wolf approach on our learning journeys. But participating in developer communities, especially early on, can really payoff. Many new technologies, the ones with a lot of buzz that you’re eager to learn, are surrounded by active communities on forums like Stack Overflow, Slack, GitHub, and even local meetups. be engaged

Learning

These online or in-person communities are great resources for receiving help. Working alone, you might find yourself blocked by a problem for days, unable to make meaningful progress. Chances are, you’re not the first person to experience this pitfall and a fellow coder could help illuminate the path forward.

Social Support

Next, not knowing something or stepping into unknown territory can feel very isolating. Meeting others in similar positions can help ease the emotional burden of the learning experience. With community support, learning can be fun, especially when you have someone (and somewhere) to share your wins.

Honing your Craft

Engaging with a community is also a great way to expose yourself to different styles of coding. You will get a glimpse into other people’s projects, what technology they’re using, and how their using it. You’ll have an opportunity to interrogate other people’s code and also pick up tips and tricks to add to your own coding style.

Giving Back

During this process, take the opportunity to give back to the community. You can do this in a lot of different ways: Write a blog post about your experiences, share your code, answer questions, request new features, point out areas for improvement in documentation. You could even PR into an open source library once you’ve honed your skills.

Recognize Patterns & Find what is Familiar

Good patterns tend to repeat themselves in software. Even if you find yourself in what feels like completely unfamiliar territory, most of the skills you’ve used to develop apps in one language, framework, or discipline will still be applicable. For example, if you’re taking the leap from frontend state management to database management on the backend (or vice versa) you’ll notice the event driven architecture of both hum to the same tune.

By recognizing these similarities, you’ll be able to learn faster. Try to implement code in a way that feels familiar. If the way you normally write code is clean, efficient, well-documented, and structured appropriately you’ll be able to find your groove in no time. (And if you don’t, what a great time to start!)

Identifying these patterns may also help you gain a more solid understanding of your already familiar tools. For example, after using it for years, I found that there was a lot to my current development stack that I took for granted. While implementing state management from scratch in my Unity project, I gained a new appreciation for the mechanisms underpinning the unidirectional data flow in Redux and the value of having a single source of truth.

Reflection & Sharing

During your learning journey, take time to reflect and share your experiences. I recommend keeping a daily developer journal of your highs, lows, pitfalls, and “ah-ha” moments. This way you will have a record to look back on when you want see how you have progressed over time, want to gather material to share with others, or when you need inspiration. You have a number of tools to choose from to help get this job done: jrnl, notion, good old notebook, just to name a few.

If you’re working as part of a team, candid daily reflection in scrum standup is a great way to share your learning experiences. Just like engaging an online technology-focused community, this can help you get through blockers, inspire others on their own learning journeys, and maybe create a supportive micro community inside your workplace.

Reflecting and sharing may seem tedious, especially on top of the stress from learning a new subject, but I think the benefits make it worth while. First, sharing what you’ve learned, where you got stuck, and how you got un-stuck could help other developers who are new to this topic. Second, reflecting on your experiences and teaching others will help reinforce what you’ve learned. Third, sharing along the way, especially with coworkers and friends, keeps you accountable and can help you persevere through rough patches.

Conclusion

There are always going to be opportunities to learn and grow in the field of software development, and I hope you take as many as you can. As you learn new things, you are improving your creative thinking skills and creating muscle memory in your brain for handling “newness”. The more skills you have learned, the faster you will be able to pick up new ones. Having the right mindset, creating a solid foundation, engaging communities, recognizing familiar patterns, and reflecting on your experiences will help you tackle these challenges with ease.

We are the creators of Shoutbase, a tool to optimize how software developers track and spend their time.

Want to know when we post new articles?