This quarantine has provided me with more time to think about the direction of my career—negatively and positively in equal measure. I am still unsure of the exact details, but what I have spent most time thinking about is being professional. Yes, before, I could piece up functions to make my android apps do what I wanted, but I kept running into some common hurdles. For example, I have spent more time than I care to remember thinking about what to do when my apps are switched from portrait to landscape. I have also really thought about the structure of my classes, with all the messy code in a single place.
I of course turned to GitHub to look at sample examples of professionally written android apps, and I was not really shocked to realize I did not understand the code base of a single repository. I hardly understood how all the pieces connected together, and this immediately cast doubt on whether I could start contributing to open source.
To get a clearer direction, I reached out to people I looked up to. And the general consensus was that I should learn three things: app architectures—mainly MVVM architecture, the Databinding library, and Dependency Injection. As a beginner, I had always thought these to be intimidating topics to learn. They have a learning curve. The learning resources are limited, and it is worse if you are trying to learn them in a recent programming language—Kotlin in my case. I felt defeated even before I began. As every google search on ‘introduction to [x] in Kotlin’ (where x is either MVVM, Databinding, or Dependency Injection) brought zero to none results, my heart sank, slowly convincing me I’d never be a real Android developer. As I usually do when faced with a hurdle, I took a break from everything. In my short sabbatical, I remembered how I got here in the first place. I got this far by diving head first into a concept, and trusting that I’d grasp it somehow along the way.
When I got back, I decided to start with architectures—MVVM in particular. I got a few tutorials written in Java, and chose to follow the implementation rather than the exact examples. It took me a while, but when I did my first example in MVVM, I was quite pleased with the result. It was far from perfect, but it was honest work, a step in the right direction. I found out MVVM heavily relied on things called Live data, which as literal as it sounds, it wraps data that is live, data that is updated at runtime. I decided to do it a second time, this time, not relying on online resources, but to try and make my own from scratch. Of course, making it a bit more complex along the way. This time, the results were better: and my understanding of the concept was reinforced, my confidence restored.
With MVVM in the bucket, I moved to the next: Data binding. The second monster remember? The techniques I used in learning MVVM were useful this time. I scraped the web for tutorial blogs on data binding, and dove headfirst into it. It was far easier this time, albeit the debugging was demoralizing since databinding uses a lot of annotation processing. It took me about three hours of implementation and debugging, and at about 2 in the morning, I heaved that sigh of relief of everything coming together properly. I couldn’t stop rerunning my code just because everything seemed so clean. I was confident I am on the right path, the people I looked up to approved my code, confirming I was on the right path.
I don’t know if I am a professional developer yet, but I do know something: patience, persistence, and throwing yourself into the murky waters certainly has its own benefits. If you are uncertain about a concept, try taking a step back, and when you resume, let go of the fear of the concept, and just get started. Hopefully, I will remember these lessons and carry them on even as I learn Dependency Injection, and beyond.
Latest comments (0)