Welcome to a brand-new series on Future Studio! We just published a blog post discussing why we're ending regularly scheduled Android tutorials and shift to a new focus: for the last two years I've been researching during my day job how developers understand code and what programmer expertise really is.
Why are some programmers so good? Why is sometimes code so easy to understand and sometimes a complete nightmare? Why are some colleagues getting better and better, and some are not?
In this series, I'll share a lot of findings what groundbreaking research on developers is discovering. In essence, you'll learn in small, actionable bits how to become a better developer. We will explore a lot of different topics: how to easier understand that terrible code your coworker is writing, how to avoid writing terrible code yourself, how to help your coworker write better code, how to quickly learn new paradigms and patterns. In short, how to become a better developer.
These tutorials are not targeted at a particular audience. This series is not specially catered for new Android developers or expert Python developers. The goal of these tutorials is that every software developer can take away something from it, because it applies to every software project, independent of language. Let's go 💪
How to Become a Better Developer #1 Series Overview
Rule #1: Don't Be Afraid - Act Like a Toddler and Keep Exploring
Let's start with the most important paradigm: the #1 rule of every programmer should be to keep exploring.
Have you recently observed a toddler, perhaps with a new toy? They might have no idea how to solve that particular puzzle and don't know how to ask their Google Home or Alexa for a quick fix (yet). No, they have to solve this challenge by themselves.
What do they do? They try, try, and try again. Eventually, they'll learn how to solve this particular problem by a time-consuming exploration of all options. Then, after failing many times, they've finally succeeded and they're ready for the next, even more complicated puzzle.
This is how we humans (and all other creatures) master a topic. We try out something new, possibly learn a painful lesson, but gain a little bit of experience. If you would be a video game character, your XP bar just grew a little bit. Once it grew enough, suddenly you'll level up and gain or improve your skill.
You as a software developer should treat programming the same way. Whenever you play around with a new puzzle, language, or pattern, you'll learn something. You might not notice an immediate effect, but in the long-term, you'll gain valuable expertise. There is no cheat code to Level 99 in software development, you'll have to take a lot of little steps to get there. We all started from zero, that high-level expert programmer on your team isn't particularly talented, they just completed many little "missions".
Exploring On Different Scopes
There are many ways you can try out something new. You could stay within your ecosystem. For example, if you are an Android developer and have been using Picasso as an image-loading library for the last few years, you could give Glide as an alternative library a shot. Maybe the additional features are not needed in your current project and you won't end up using your exploration branch, but don't be discouraged from it! You may need these additional features in the next project and then it's your time to shine: you already know Glide.
The idea of exploring does not only exist on specific libraries, but also on more general implementation patterns. There are always multiple ways of solving a problem, but what is the cleanest? The most robust? When you're facing your next feature implementation, don't directly jump in and implement it in the style you're used to. Think whether there could be a better pattern to solve this issue. If you haven't been exposed to too many patterns, I can highly recommend the Head First Design Patterns: A Brain-Friendly Guide, it's an excellent book proving an overview over many patterns.
Again, don't forget that you need to be exposed to many new ideas and perspectives to grow your skill set.
Lastly, and in my opinion the most important one, explore programming outside your usual domain. That is, if you're an Android developer using Java, explore a web framework with a dynamically typed language like Node.js. In this case, I recommend to write a small sample API you can write the Android app for.
This has several advantages. First, you'll change your view and see the world from an API developer's perspective, which gives you insight in their problems (and possibly why API designs are sometimes so bad). Second, with Node.js, you'll be exposed to a completely different way of programming. Even if you never use Node.js again, you'll take some concepts and ideas back to your Android world. For example, if you chose to learn hapi, you'll love the modular design and will immediately re-structure your Android app code in largely independent components.
In this tutorial, you've learned an important lesson. Never get discouraged to keep exploring! Whether you try a new library, paradigm, or language, you'll always learn something. Nobody can take that way. Keep piling up these experiences and, at some point, you'll notice a small jump.
Congratulations, you've just leveled up your programming skills 🎉
Do you have further questions or suggestions on this topic? Let us know on Twitter @futurestud_io or leave a comment below.
Enjoy coding & make it rock!