If you’re familiar with the world of software development, you might have come across the acronym RTFM.

It stands for “read the frickin’ manual” (or its more obscene counterpart). You might have heard it if you’ve ever found a bug in your code and asked another developer for help. Instead of helping you, they tell you to RTFM before you ask them any more questions. 

6 beginner app developer mistakes

When you’re just starting your app development career, being told to RTFM is a bit crass and dismissive. After all, mistakes lead to insight and if you don’t make mistakes, you won’t learn anything. Instead of reading the manual to avoid mistakes, sometimes it’s best to make many as possible. Here are some of the most common mistakes that beginner app developers make, and what you can learn from them.

1. Trying to build the next Facebook 

Imagine you’ve got a great idea for a new app, and that’s prompted you to learn app development. You dive in head first, seeking out components and concepts you want to incorporate into your new app. You decide to add a complex augmented reality (AR) feature to your app.

It may be smarter to first learn about variables and functions, which are fundamental app development topics. A common mistake beginner app developers make is biting off far more than they can chew. They want to build the proverbial next killer app before even learning about fundamental software development topics.

Learning how to code doesn’t need to be boring, though. It helps your motivation when you see the results of your work. Building an AR app can feel more rewarding than mastering a programming concept because it’s more tangible. It’s smart to create a balance between the two—for example by creating a simple to-do app while mastering fundamentals.

2. Not reading documentation 

Speaking of RTFM, it is actually important to read the documentation. Major software platforms, such as Android, iOS, and mobile development frameworks like React Native, have put extreme care into building documentation, guides, and tutorials for developers. Within those docs often lie the answers to simple questions, but you’re not going to find them if you don’t look.

The problem with the official documentation is that it’s not written with beginners in mind. If you take a look at a page from the Swift Language Guide for iOS apps, you’ll quickly realize that you need a basic understanding of programming and terminology to comprehend what’s on the page.

Imagine you’re learning how to code iOS apps and you consult the documentation. A few things can happen:

1. You struggle to comprehend what’s on the page, but you dig in and have more trouble than necessary learning how to code.
2. You’re intimidated by what’s on the page and give up learning how to code as a result.
3. You make a note to never check the documentation again, and learn to code with another resource such as a book or course.

In each of these scenarios, the documentation loses its potential value to the coder. However, with some patience, you can still learn a great deal from the documentation as a beginner app developer. 

Regardless of whether or not you end up using the documentation to learn to code, remind yourself to consult the documentation every once in a while. The more you try, the more valuable the docs become.

3. Too much time between learning sessions

The most popular course on Coursera, Learning How To Learn, answers a crucial question: “When I’m learning something new, how do I set myself up for success?”

Instead of discussing a subject matter, this course teaches practices based on how to learn more effectively. One of these approaches is called spaced repetition, and it applies to learning how to code.

For example, imagine you’re learning how closures work in Swift. You set aside two hours on a Thursday evening and promise yourself you’ll spend more time learning on Friday. Instead, life gets in the way, and you don’t look at it for another two weeks. Guess what happens when you get back to closures two weeks later? You’ve forgotten much of it and need to spend more time revisiting the topic.

The opposite is true, too. If, in your enthusiasm, you spend two days straight on learning how to code without recovery time in between sessions, what happens next? The law of diminishing returns kicks in. You forget half of what you learned because it’s simply too much to comprehend.

Spaced repetition is often used for rote learning, like vocabulary, but it applies to skill-based expertise too. When there’s time between learning sessions—not too much, not too little—you learn more and need less time to revisit what you learned previously.

To take advantage of this approach, figure out a schedule that works for you, such as dedicating two evenings a week to learning how to code. You’ll build a habit if you stick to that schedule, and the amount of time between learning sessions will help your comprehension.

4. Learning without a plan

Most developers are self-taught, which means that they get to decide what topics or skills they learn next. If you’re new to app development, you might find yourself searching the web for interesting tutorials and articles about coding. When you come across a bug you need to fix, you type the error message into Google or find a solution on Stack Overflow.

This works okay for a while, but over time you start to develop gaps in your knowledge. Pieces of the puzzle are missing because you’ve learned only the topics that tutorials lead you to. On top of that, many online tutorials don’t teach fundamental topics but merely provide step-by-step instructions. You need insights to move forward, not instructions. So how do you connect the dots?

Create a learning plan for yourself. Outline the skills you want to develop, the goals you want to achieve, and how you’re going to get there. Knowing why you want to learn how to code can shape that plan too. Learning and practicing deliberately make a huge difference in motivation, effectiveness, and results.

Let’s take a look at a practical example. Imagine you’re coding your app, and you’ve found a bug in your code. Something doesn’t work, and you see an error message. What if you pasted that error message into Google? You’d probably find a solution, apply it, and be done. You learned how to solve this error, but have you learned anything that might help you solve the next error?

What you could do is go a step further and add debugging to your learning plan. You want to learn how to debug your code, and how to use the tools needed to do so. That might lead you to insights about error handling, maintenance, and code architecture. Instead of just fixing the bug, you deliberately sought out topics to learn more about. This becomes the foundation you build your apps on.

5. Neglecting to revisit and refactor

A smart app developer keeps notes of all the things they’ve learned. A notebook of tips and tricks for coding, if you will. In it, you can write short notes for yourself to explain step-by-step how to get to a particular result, for example, how do you build a table view in your app? Or, how do you integrate with a back-end database? 

Later on, in case you forget these things, you can look back to your notes. After a while, patterns and principles emerge. You’ll see that the basic building blocks of app development are almost always the same ones.

Some developers only start projects but never finish them. It’s perfectly fine to try out lots of things, but not finishing a significant share of your projects can become a bad habit. The last 20% of a project often takes as much effort as the first 80%, so there’s a lot to be learned from applying the finishing touches. Most real-world app projects are built to spec, so you’ll need to deliver to a client or a customer at some point. Cultivating that real-world experience early on helps you get ready for actual development projects.

One last skill that beginner developers must learn is refactoring. Refactoring simply means rebuilding or changing a component in your app to make it more performant, easier to maintain, or easier to debug. The app itself isn’t different from the outside, but what’s on the inside makes all the difference. For example, can you change your code in such a way that it becomes easier to read? Refactoring (and practicing refactoring) is what will get you there.

Ultimately, building apps is an iterative process. You revisit what you learned before, and built before until the app is almost perfect—and that’s good enough!

6. Not doing any marketing

If you’re learning how to code apps, chances are you also want to launch one. It’s a great feeling, seeing your own app out there in the App Store. You’ve coded your app, added the finishing touches, and finally hit publish. But then...crickets.

Marketing is the art of getting people to change their minds. It happens when people move from using product A to product B. First, they used one solution to solve a problem. Now, they’re using your app to solve that problem. Marketing is what makes that change happen.

The problem is that most developers are logical, analytical thinkers—that’s what’s got them interested in app development in the first place. They think, “when I need a quarter-inch hole drilled, I need to buy a quarter-inch drill bit.” Quite logical, isn’t it?

Marketing an app is as simple as that too. However, doing marketing doesn’t mean that people will know about your app straight away. You need to help them discover that your app can solve a problem that they have. It’s not rocket science, but you’ll need to remind yourself to take a step toward encouraging those who can benefit from your app to actually use it.

Begin by making mistakes

Learning how to code apps isn’t always about knowing what to learn. How you’re building your expertise and shaping your path forward is just as important. You know the most common beginner app development mistakes, now go ahead and create some more—so long as you’re learning from them.