This post may contain affiliate links that earn me a small commission at no additional cost to you. For more information read my Affiliate Disclosure.
In Facebook groups and other communities, I see a lot of people asking how they can start learning Android development. There seems to be a lot of confusion about the “correct” way to start, which is no wonder given the vast amount of resources available. There are books, videos, blog posts and an endless number of documentation pages. There are free resources, paid resources and some really expensive resources. There is simple content, difficult content and outright confusing content, and it can feel really hard to estimate if you’re actually making progress or if you’re just wasting your time. With this post, I want to provide a guide that helps beginners with zero experience to get started with Android programming, and which I can then refer to whenever someone asks for help somewhere.
This post will not teach you any actual programming. Instead, I will show you the resources you need (and don’t need) to get started and explain how you can keep learning by yourself after you took your first steps.
As usual: Take my advice with a grain of salt. What I explain here is my personal opinion for a good way to learn programming. But then again, I am not a professional developer myself. My subscribers often ask me how I learn all the stuff I explain in my videos and here you can find the answer. I am 100% self-taught and this post is directed towards everyone who wants to do the same. This is not a promotional post where I try to sell you a specific course, but rather my honest opinion and my own personal learning approach.
Does it even make sense to learn native Android development anymore? Isn’t it better to use React Native or Flutter? And what about Fuchsia? It will replace Android soon, right?
Android and iOS are the 2 biggest mobile operating systems on the market and companies often want to have their apps available on both platforms to reach a larger audience. For that, they have to choose if they want to develop 2 separate “native” apps or use a cross-platform framework instead. Writing a native app means that you use the language and development tools for a particular operating system — Android or iOS — and then write code that will only run on this one platform. If you then want to have the same app available on the other operating system too, you have to rewrite it from scratch in that language. Of course, this can be quite expensive and time-consuming, especially when it requires a separate team of developers. Cross-platform frameworks like Ionic, Xamarin and React Native let you write a single code base that works on both operating systems. I don’t want to go into the details here about how they work, but all of them have downsides like worse performance, less available features, security issues and a more stressful and problem-prone development process. Because of these limitations, native apps have always been superior for anything that goes beyond very simple functionality.
Flutter is another cross-platform framework developed by Google itself and apparently, it creates very performant and good-looking apps, makes the development process faster and easier than previous solutions and has good documentation. Flutter just hit stable version 1.0 and gets promoted by Google quite a lot, but the Android community doesn’t really seem to know what to make of it yet. Some say Flutter is the future, other’s say Google is likely to kill it in a few years, and again others say that it will not play a bigger role than it does right now. Also, it still can’t use all the features and libraries that a native app has available.
Let’s keep it short:
If you want to learn mobile development mainly as a hobby or if you want to build an app for your startup that relies more on displaying content and not on complicated features, you can consider learning one of the cross-platform frameworks right away (and skip this post). If you want to work as a programmer and maximize your chances of getting a job, you should build a solid foundation and learn native Android development first. You should also choose the latter if you just want to build an Android app and don’t care about iOS at all.
You also have to keep in mind that as of now, it is much harder to find (clear) tutorials, code examples and answers to your programming questions that are written for Flutter and co. than in native code. As a beginner, this makes the learning process incredibly more time-consuming and frustrating.
If you follow Google-related news, you might have also heard about Fuchsia. Fuchsia is a completely new operating system that Google is currently developing and which could replace Android in the future, but again, nobody knows for sure. But even if that really happens, it will take a few more years before becoming reality. And even then, Android apps will still run on Fuchsia (there are already hints that confirm that), because Google can’t afford to just drop the millions of Android apps out there and alienate all existing Android developers.
At this point in time, don’t worry too much about these new frameworks. Native Android development will not become obsolete soon, and once you have experience with it, learning another language or framework will become easier. It’s not like you later have to start from zero because you accidentally picked the wrong starting language or platform. By understanding the underlying logic, data structures and design patterns of the code written by yourself and others, you are building software engineering skills that transcend the language or framework you’re currently working on. Just pick something and then stick to it for as long as you are a beginner.
Ok, I want to learn native Android development! Should I start with Java or Kotlin?
Now that we’ve decided to go for the native route (at least I assume that because you are still reading), we still have to pick between one of 2 languages, because native Android apps can not only be written in Java.
You probably already heard that Kotlin was introduced as an official “first-class” language for native Android development at the Google I/O 2017. Kotlin is a modern programming language with a lot of benefits over Java, like a more concise syntax, null-safety (that means fewer crashes) and a lot of other features that make writing code easier. At this point, you could theoretically build native Android apps without learning any Java at all. So, as a beginner, should you skip Java and jump right into Kotlin? Or should you learn good old Java first? Maybe learn both at the same time? I wrote about this question in more detail here, but if you don’t want to read this post, the following is a quick summary. However, if you still find yourself having a hard time deciding between Java and Kotlin, go ahead and read the full article for more clarification.
The summary is: Start with Java. There are much more learning resources for Java and it is still the much more wide-spread language. Learning Kotlin without also learning a bit of Java simultaneously is not really feasible right now, so you would have to learn both at the same time, which would just add more confusion. Ignore the hype around Kotlin for now and build a solid foundation, especially if you consider working in a programming job outside of Android in the future. Kotlin, while growing in popularity quickly, currently has its biggest role in Android development, but not so much in other areas. A big part of the code bases of big companies is written in Java, and so there are disproportionately more open job positions for Java than for Kotlin (I show some numbers in the post mentioned above). Most Android jobs nowadays also need you to have Java skills, while Kotlin is mostly still just nice-to-have. And even though Google promotes Kotlin heavily, they are not planning to drop Java support, both are meant to be equally valid first-class languages which can do the same things that the other can (although Kotlin might make some things easier).
You can still learn Kotlin later down the road when you feel comfortable with Java. That’s absolutely no problem. As I mentioned before, learning programming is not so much about memorizing a particular language, because the language is just a tool. Learning Kotlin when you are sufficient in Java will take a few weeks at most, and both languages can be used interoperably in the same project, so the transition should be quite easy.
But I don’t know where to start! Should I buy books or courses? And should I follow every instruction step by step?
Generally, the best way to learn programming, is by building your own projects and researching every step and problem that comes up along the way. For this, you don’t need any books or courses, and they can even be detrimental in my opinion. I will talk about this in more detail later in this post.
However, if you are just starting out you probably have no idea where to even begin. Maybe you don’t even know how to install an IDE (an “Integrated Development Environment”, the thing where you write code in) like Android Studio. At this stage, trying to figure out everything on your own with Google searches is just too difficult and confusing. For this reason, I would recommend that you use a good, well-structured beginner book or course to learn the absolute basics.
The book I started with was a plain-Java book called “Head First Java”. It was good, but it doesn’t teach you anything specific about mobile development. When I realized I want to go for the Android route, I looked for some more Android specific resources and ended up with the free Android beginner courses on Udacity, which I personally found extremely helpful and well done. Here is a link to the first part of the series. These video lessons are made by Google, all the parts are free and you don’t need any Java experience to start. There is no problem with learning Java and Android at the same time, so you don’t need any further preparation (You also don’t need to buy the Head First Java book). The courses will teach you everything you need to get started, including the very basics, like what classes, variables and methods are and how to build a layout. Of course, you can start by learning a bit of plain Java first if you feel more comfortable with that, but it’s not mandatory. There is also a paid version of the same Udacity courses, but you only need them if you want a Nanodegree, which is some sort of certification from Udacity.
There are other good Android beginner books and courses, but right now I don’t really see why you should pay 30 bucks for something that you can get for 0$. The free Udacity courses are more than enough, and they have a really high quality. They are already more than 2 years old as of writing this post, but since they cover the basics, that shouldn’t be a problem, because the basics don’t change very much. Of course, I don’t know how long they will be available, and they might remove the videos at some point. If that happens, just take any book or course with good ratings and start there. It doesn’t matter too much which one you pick, because they are only supposed to get you started. The real learning happens on your own, as you will see later.
Also, make sure to not just passively watch the course or read a book, but to actually practice yourself by typing out the examples and doing the exercises provided there. Even if you think that you understand everything while you’re watching it, the first time you actually try to write the code without any help, you will suddenly not remember anything. That’s normal, and we all made that experience at some point. You can only learn coding by writing a lot of code over and over again.
Did you know?
You can support my free content without paying a single dollar!
That being said, I would recommend that you try to finish the courses as quickly as possible. These lengthy formats are just a too passive way of learning in my opinion. It’s very comfortable when someone tells you step-by-step what you have to do, but it’s also not very effective. The more you engage with a problem or concept, the more it sticks. You can increase your engagement level with the content by not just typing out the code examples from the course directly, but trying to figure them out yourself without any help first and then only looking at the solution (or the next step) when you’re stuck. Even better, use different class-, method- and variable names, change the layout and build the example slightly different from the one you see in the course. This way, you increase the difficulty level and have to think more for yourself. If you enjoy that, do it for the whole length of the course and take your time. However, chances are you will become bored and frustrated pretty quickly and the coding exercises will feel like math homework. If this happens, and you keep procrastinating, just skim through the rest of the course and finish it as quickly as possible to get a general overview of the concepts. You can then build on that with more exciting ways of learning. When I finished “Head First Java”, I couldn’t explain or recreate any of it afterwards, but I knew that there were things like “interfaces” and “constructors”, which I then learned more in-depth about later on. I also didn’t finish all the Udacity courses till the end, because I got bored.
Another problem with curated courses is that you follow the approaches and opinions of a single or a few people, which gives you kind of a narrow view when you later learn about more advanced topics. With shorter forms of content like blog posts, Youtube tutorials and existing online discussions, you can see a lot of different approaches by different developers, simply because you can read and watch more of them, and this way get a wider range of input. Also, books and courses get outdated pretty quickly, because the programming world evolves quickly. As mentioned earlier, the more basic the course is, the less likely it is to get outdated because the basics don’t change that much. Shorter tutorials, of course, get outdated too, but since you can easily watch many of them, they give you a better overview of what changed over time and what stayed the same, rather than a momentary “snapshot”.
Personally, I very rarely buy or even watch free programming courses (or books). I don’t have a problem with paying money for learning resources, but I always found Google search and shorter tutorials to be a more effective way of learning.
How do I learn on my own?
The great thing about mobile development is that it is so easy to build something “real”. Not just some console output, but apps that you can actually use and install on your phone. The Udacity courses I recommended, quickly teach you how to use the XML Editor in Android Studio to create a simple layout with text, images and buttons and then add some basic functionality to them. This is much more fun than spending your time solving boring book exercises where you try to create Christmas trees with if-statements. Once you’ve learned the basics (i.e. how classes, variables and methods work and how to build a simple layout), you don’t really need anyone to hold your hand anymore. Instead, you should soon start creating your own little projects — real apps that can actually do stuff — and learn everything you need to know along the way. Depending on how far you followed the beginner course, start with something simple that fits your current skill level, like a calculator that just adds two numbers or a button that brings you to another screen, and then steadily increase the difficulty level by implementing more and more complex features. Enjoy the coding process as much as possible and don’t hesitate to delete a project and start over again. Your second or third project could already be a to-do list app that stores data in a database or a fully functional calculator. Ideally, you should create apps that get you excited and maybe solve one of your own problems, but don’t get hung up on “finding the right idea”. If you can’t think of a new app, just copy one that already exists. I would recommend that you skip the complicated online features at the beginning, as well as advanced concepts like software architecture and dependency injection, and start with simple offline features, like how to implement different types of menus and widgets, how to process input, or how to save and load data on the phone so it doesn’t get lost after closing the app. I would also recommend that you learn things just when you need them. You don’t have to sit down and study each concept in theory before you can apply it, just learn it along the way. For example, I didn’t understand what interfaces, generics or lambdas were even though I tried to read it up in theory. It only started clicking once I actually used them in code and experienced how they work.
If you want to see roughly in what sequence I learned the different topics, take a look at my videos on YouTube in reverse chronological order. Since I started making videos when I was a total beginner, this gives you a pretty good overview of my learning timeline. Get some inspiration from there.
And here comes the most important part. This is how the learning process should unfold:
You see an interesting feature that you would like to try out and add to your app. Maybe you want to know how to get a drop-down menu into the toolbar or how to display a countdown timer. Your first destination should always be Google search. Don’t go into a Facebook group or another community and ask “How do I add a menu into the app bar?”. This is a slow and lazy approach that will ultimately not teach you very much. Instead, type “android studio how to add app bar menu” into Google and go through the results. The official developer.android pages should obviously be your first go-to, but they are not perfect, so make sure to also go through other results. With time, you will figure out which resources are more and which are less useful.
When you found a tutorial or instructions, try them out yourself! Don’t just read or watch, because that won’t stick. Your first goal should be to get the feature to work on the emulator or device. It doesn’t matter if you understand everything right away, you can still learn about the details later. Just be patient and don’t get frustrated. Sometimes this process will be easy, often times it will be full of obstacles and very confusing. When you run into a problem, and you don’t know how to solve it, don’t immediately go back to Facebook and ask others to solve it for you. Instead, try as much possible on your own. Got an error message? Copy it into Google! Chances are, many other people had the same error message before you and already came up with solutions. Don’t know what a certain method or attribute does or how it works? Copy it into Google! I hope you can see a theme here. As a programmer (not just as a beginner), Google Search is your best friend. If the whole tutorial seems to be outdated or incorrect, try a different one. Here is a blog post where I explain in more detail how I use Google to find what I am looking for.
My YouTube subscribers (and people in my personal life) regularly ask me how I learn all the stuff from my videos. Some people seem to think I found some sort of super comprehensive guide or that I have very good teachers. I have no teachers, I don’t buy courses and I didn’t study computer science. I just sit at home and google all this stuff. There’s really nothing else to it, and it’s almost completely free.
Here is an important thing you have to keep in mind: Effective learning is often uncomfortable and frustrating and it is supposed to feel that way. If you try to comprehend something that is out of your current skill level, it will often feel awkward and confusing and you might think about giving up Android or software development altogether. But those are the times when you make the most progress, because you’re outside of your comfort zone. It’s a bit like the last reps in the gym that are the most painful, but also the most effective. Whenever you try to understand something difficult, you get a little bit better at it (even if it sometimes feels as if you are taking steps back). Your brain needs something to chew on in order to grow and if everything comes easy all the time, that just means that you’re not challenging yourself enough. This is not a motivational rant, it’s just the truth. I recommend that you read my articles about the growth mindset and deliberate practice, where I talk about the proper way to approach challenges.
Equally important as using Google, is learning to read source code. In Android Studio, you can jump to the source of a class, method or variable by holding Ctrl/Cmd down and clicking on the name. Alternatively, you can put the cursor on it and press Ctrl/Cmd + B. Reading other people’s code is daunting at first, but it will become easier with practice. You will be amazed by how much insights and aha-moments you can get by just following the execution flow step by step and reading notes that other developers left there. You will not only find solutions to problems this way, but also start understanding how the deeper layers of code work.
Now, when I say that you should try things out yourself first, I don’t mean that you shouldn’t ask any questions ever. In fact, I think you should ask a lot of questions. But these questions should be well-thought-out and narrowed down to a particular problem. Ideally, you would ask for hints and not for complete solutions, unless you are in an emergency situation (like a close deadline).
An example of a good question:
“Hey guys, I added a toolbar into my app, but now the text and icons are black instead of white. I tried using the titleTextColor attribute, but that doesn’t change the color of the overflow menu. Is there an attribute that changes the color of all the views in the toolbar? I already searched Google for an hour but I can’t find a working solution. Here is my XML code (properly formatted, not an obscure photo of the screen) and a screenshot of the toolbar, can you help me?”
An example of a bad question:
“Hey, how can I change color in toolbar? It’s not working.”
Both questions might get you to a solution earlier or later, but in the first example you thought about the problem intensively, you tried things out yourself, you learned which approaches don’t work, you narrowed down the problem and then you asked a specific question. In the second example you most likely just stopped trying as soon as the problem came up and loaded the question off to others to solve for you. Or you haphazardly tried a few solutions but didn’t really think about what you’re doing. Even if both questions get you to an answer, you learned much more in the process of the first example. It’s also more likely that people are willing to help if your question is specific, because then they don’t have to explain the whole topic or guess what exactly your problem is. This also means that you shouldn’t just post 200 lines of error messages in a comment and hope someone unravels it for you.
After you got an answer, you repeat the same steps as before: You try it out, you google new problems and uncertainties that come up and if you get stuck, you ask another specific question.
You can get the highest quality answers for programming question on StackOverflow (the most popular Q&A platform for programming topics), but they are also the strictest when it comes to question quality. A lot of beginners (including me) burn their hands here and get a lot of downvotes because they ask very basic questions that have been answered before already. In Facebook groups, on the other hand, you can ask pretty much anything, but the answers are generally not very reliable (if you get any at all). If you want a forum that is not as strict as StackOverflow but still has pretty high-quality answers, take a look at the androiddev Subreddit on reddit.com. People there are willing to help and I use it myself a lot. And of course, you are welcome to join the Coding in Flow Facebook group, where we try to help each other too.
Besides that, I am not going to recommend any particular resources here, like specific blogs or YouTube channels, because I think this should naturally evolve from your research process (i.e. Google search). If I list 20 YouTube channels, website and newsletters you should follow, it will just overwhelm you with information. The purpose of this post is to get you on your own feed. With time (i.e. the more you search in Google) you will figure out yourself which sources are useful and which waste your time. However, I will recommend some ways to stay up to date about the latest changes in the next chapter.
I emphasize this researching process so much because it’s crucial for your progress and career. The most important skill as a programmer — not just when you’re starting out but also later in your job — is not to know how to implement feature XYZ, but to figure out how to implement feature XYZ and then understanding the solution. And you learn this by reading tutorials, documentation and source code, by asking good, explicit questions and by drawing your own conclusions from all that information. The framework, the libraries, the correct way of doing things and even the languages change over time, so don’t get demotivated when you don’t know how to do something or when you have trouble understanding it. See every new concept that comes up as an opportunity to improve your research- and study skills and to learn a bit more about software engineering in general. This is also why you shouldn’t worry too much about picking the best framework or language or memorizing the code you write. But there is also no one that can handhold you through this whole learning process from start to end. There is no book or course that can teach you everything you need to know, and then you can just sit back and relax while the code effortlessly flows out of your fingertips for the rest of your career (but this would be boring anyways).
No matter how you learn, try to be consistent with it. As long as you are a beginner, stick to one language and platform and don’t try out tons of different things, because then you will always just be busy learning the basics over and over again. Also, don’t leave any big gaps between single learning sessions and ideally try to learn a little bit every day, unless a special occasion comes up. There will be days or weeks when you don’t feel like writing any code at all, but I would encourage you to still do a little bit or at least read something programming-related and this way give your brain some information to process. Small, consistent steps will let you progress quickly.
How can I stay up to date?
As I said before, which particular channels and information sources you follow will evolve naturally from a self-guided, autonomous approach to learning. However, I want to give you a few ways to stay up to date with the latest events in the Android development world (which then helps you pick more specific sources).
This is what I use:
The official Android Developers Blog is a good source to get informed about the biggest Android dev announcements. Personally, I have set it as my browser homepage, so I immediately see when a new post is up.
But the Android Developers Blog alone is not enough to keep you up to date about everything, because there are small news and noteworthy changes happening every day. Again, I find the androiddev Subreddit very useful to stay up to date and additionally I follow the #AndroidDev bot on Twitter, which basically retweets all posts with the #androiddev hashtag after putting them through a spam filter. Twitter has a lot of noise, but it also gives you a very comprehensive view of what is going on in the programming world, because everyone is posting there. Remember that you can mute accounts that post too much uninteresting stuff to reduce the overall noise.
What else can I do?
Learning programming is difficult and you need to figure out ways to stay motivated in the long run. I’ve thought and read a lot about motivation and discipline, and I am always trying to find better ways to beat procrastination while maximizing enjoyment of the process. Those are the kind of things I write about in my blog posts. My YouTube videos contain the technical stuff and programming tutorials, while on my blog I write about more general topics like motivation and mindset, as well as secondary skills and habits that you should develop as a programmer.
Here some posts that you can read right now. Pick one to get started:
- How to Beat Procrastination
- 5 Non-Technical Skills and Traits You Should Develop as a Programmer
- How to Get a Job as a Programmer
- 5 Personal Development Books You Should Read as a Programmer
- How to Stay Healthy as a Programmer
And then I wish you good luck and a lot of fun on your journey!