My journey from online courses to professional developer
Over the past year, I went from not knowing the difference between a class, object, or method to landing the dream job at WillowTree. I started with a popular online Android program—and it was awesome—but some of the most vital information I learned came from resources outside the courses. Here are some of the topics I felt the big programs left out, and the techniques I used to dig into them.
Computer Science Fundamentals
Don’t dwell on this topic, but, instead, consistently work on it in parallel to your platform. Some of the more difficult topics like Graph Theory and Dynamic Programming may become clearer after taking a break and revisiting them later on. I practiced solving problems from Cracking the Coding Interview and worked through algorithm challenges on HackerRank. Not only will this make you a better problem solver, it will prepare you for the technical interview.
This has to be one of the biggest points. When I began my venture into Android, I started listening to two podcasts, Fragmented and Coding Blocks. These opened up a whole new world to me. Getting insight from software developers in the field—developers facing the same problems you will face on the job—is invaluable. They discussed common problems and the varying approaches and techniques used to solve them.
I would try out libraries discussed on Fragmented or refactor a project to an architecture they suggested. Whether it’s through blogs, podcasts, or other means, make a point to get familiar with popular third-party solutions. You may even find yourself using a library or tool made by an engineer at WillowTree.
Design Pattern and Architecture
A familiarity with common design and architectural patterns (MVP, MVC, MVVM, etc.) will prepare you for the codebases you will see on the job and enable you to write better software. The projects in online courses are small enough that they don’t necessitate a solid architecture, so it’s not usually part of the curriculum. As a project grows in size and complexity, the benefits of utilizing design patterns and abstraction through clean architecture compound.
As an exercise, I would go back to my earlier projects and refactor them around a particular architecture or abstract out some functionality to utilize a design pattern. Even if it doesn’t seem immediately beneficial, try to build a project around a popular architecture or utilize some slick design patterns. This will pay off in the long run.
Although it may not be the most glamorous of topics, testing shouldn’t be ignored. Just as the benefits of solid architecture increase as a project grows, so, too, do the benefits of testing. Tests allow you to verify the correctness of your code and catch mistakes before they fall through the cracks. Look into the testing tools and frameworks available for your platform.
I made it a point to write tests for my projects, even if it was just a few unit tests. I found that I was writing cleaner, more abstracted code when I had testing in mind. Test projects are commonly used during the interview process, and having some tests written when you turn in such a project will undoubtedly look good. Even if you don’t go as far as exercising test-driven development, being comfortable writing tests and testable code goes a long way.
Hopefully these topics will offer new avenues for you to continue your self-taught developer journey. There is no one course or bootcamp that can cover everything there is to know. The most important thing is to keep learning and refining your craft—even after landing that dream job!