2021.12.31. 09h • Márton Braun
Another year over, a new one’s almost begun. Here’s a brief summary of what I’ve done in this one.
I spent this calendar year working for Stream full-time. I did this in a (somewhat) new capacity though, as in February, I shifted from a pure Android Engineer role into being an Android Developer Advocate instead.
What this meant in practice was that I started sharing my focus between building and contributing to the Android team (as I’ve been doing before) and creating public-facing content and interacting with external developers. This new dimension of my job was quite natural, given that I’ve already been contributing to the community in various ways as a GDE.
I’m really thankful to Nick and Nash who were my managers in this role, as they gave me tons of freedom to pick what I wanted to work on, and were all-around very supportive. The devrel team being built out at Stream is also awesome to work with, having experts for various areas.
While all of this was terrific, I ended up leaving Stream mid-December. I had a great time working there, and we parted on very good terms. I’d definitely recommend them if you’re looking for a new job - check out their open positions, and feel free to reach out to me if you want to learn more about the company (especially devrel or Android there).
For a quick recap of awesome things we achieved at Stream during my time there:
- We expanded the Android team from a couple people to ~10, building processes, guidelines, and infrastructure along the way to support that.
- We built and released the new XML-based UI Components at the start of the year.
- We created a new Jetpack Compose SDK team with Filip Babić as its lead, who I got to work with to build the initial version of the Compose Chat SDK. We then expanded this team to three engineers working (very happily!) on Compose full-time.
- We cleaned up tons of public API, and shipped brand new, high-quality documentation for the Android SDK.
- We created content (written and video), sponsored external creators, conferences (such as Droidcon and Android Worldwide) and other open-source libraries that we love, and gave various talks about our engineering work.
At the moment, I’m enjoying a month-long funemployment break (about half of which remains) before I get started with my next day job next year.
As far as writing goes, I’ve apparently settled into a steady pace of about one article per month, going for a couple consecutive years now, which I’m quite happy with.
Early in the year, I re-released my guide for publishing Android libraries to MavenCentral, updated for 2021. I also wrote a handful of articles on my journey of learning Jetpack Compose.
My favourite articles to write are probably the ones that explain technical topics in detail, especially if it’s about something Kotlin. The topics I covered this time around included new sealed features in Kotlin, a detailed guide to Opt-In annotations, validating Kotlin public API, and progress tracking on Android.
I’ve split the traffic on my articles between a few different sites this time around. Other than my own blog, I’ve also published on Stream’s blog and have cross-posted several articles to dev.to (which has been a pleasure to work with) and even Medium (which continues to be absolutely woeful all-around).
Virtual events brought along lots and lots of speaking opportunities, and I said yes to most that came my way. Thanks to these, I ended up more than doubling my yearly appearances, giving 21(!) talks, which included six brand-new ones, and a healthy amount of repeats (of both existing and new talks). I even went on a podcast for the first time (thanks again Holger!).
I also gotta give another shout-out here to Filip Babić: four of my appearances were joint talks with him, discussing Compose and the Chat SDK we designed and built with it. Having to do just half a talk these times made it a lot easier to fit in all these events.
In the fall, in-person events slowly restarted. I was thrilled to attend both Droidcon Berlin and London, giving a few talks to live audiences and hanging out with tons of people both at and after the conferences. Thankfully, all of this went safely without any problems. I really appreciate all the work that the organizers put in to make them happen.
To offset some of the environmental impact of travelling, I’ve again purchased ~4x of their approximated footprint in carbon offsets via The Gold Standard, and I’ve also joined the #TeamSeas party for the same amount.
University work continued as usual this year, and this year’s two semesters were the fourth and fifth runs of my own Kotlin language course.
The course continues to run at full capacity – 120 students per semester – and student feedback is still super positive. Naturally, they really enjoy coding in Kotlin, plus they appreciate the quality of the materials (especially compared to other university courses, which unfortunately don’t tend to set a high bar), and they also respond really well to the live-coded lectures that take place entirely in the IDE.
As a nice show of appreciation, the lovely people doing education outreach for JetBrains let me speak about my course and its story on a webinar hosted by them, and they were even nice enough to restock me with stickers for next year.
In the fall semester, the university went back to in-person classes, after multiple remote teaching semesters. Even with the travel time and extra logistics that this added to my weeks, it’s been really nice to be in the room with students again. It’s still hard to get students to regularly prompt me with questions, but it’s definitely easier this way than over a Zoom call.
Being a meetup organizer this year has still not been easy. With Android Budapest, we managed to host two events, a regular two-talk event online, and an in-person roundtable discussion in the summer. The latter unfortunately had low attendance, but an excellent live stream – catch the recording here!
Other than these, we continued participating in Android Worldwide, an awesome collective of Android communities running quarterly events (basically mini-conferences). I’ve also done a bunch of editing and publsihing work for the recordings, available on their YouTube channel. You can follow them on Twitter to make sure you don’t miss future events.
This year, most of my open source contributions have been through my day job at Stream, as already noted above.
Other than this, back in May I wrote a simple utility library, requireKTX, which makes it easier to deal with some otherwise nullable APIs on Android, by providing non-nullable
require... style extensions for various Android types.
As a small bonus, I completed this year’s Advent of Code challenge (all in Kotlin, naturally), and you can find my solutions on GitHub. This has been super rewarding for me (except for a couple frustrating days), and I’d highly recommend it for anyone looking to practice a language or their DSA knowledge a bit.
A year ago, I listed a few things that I planned to continue: teaching, open source, talks, blogging. I’m content with how these all went, though giving talks got a bit out of hand.
The other point I’ve had on my list was learning Jetpack Compose. I believe this has been a great success, I have a pretty good understanding of the framework, and thoroughly enjoy working with it. The View system to Compose migration feels just like the Java to Kotlin migration felt. Can’t wait to see it keep progressing in the community.
Finally, something else I dipped into briefly at the end of the year was Kotlin Multiplatform, inspired by Marc Reichelt who I had the pleasure of meeting at Droidcon Berlin. While I haven’t used it for anything serious yet, I had a good look at what it currently looks like to set up and run a multiplatform project, and I’m fairly sold on the idea.
With that, it’s time for me to sign off for this year. I’ll enjoy a few more days of serene time off, and then I’ll be back to do some even more exciting things!
See you next year – let’s hope it’s a good one.
You might also like...
Have you ever encountered APIs that show warnings or errors when you use them, saying that they're internal or experimental? In this guide, you'll learn everything you need to know about opt-in APIs in Kotlin: how to create and use them, and all their nuances.
StateFlow behaves as a state holder and a Flow of values at the same time. Due to conflation, a collector of a StateFlow might not receive all values that it holds over time. This article covers what that means for your tests.
Let's send this one off so that we can get started on a better one. The "usual" recap of what I've done this year.
Another year has come to an end, so it's time to reflect again. I'll attempt to sum up what I've done this year, how that compares to what I was planning to do at this same time last year, and what I expect to be next.