Keeping up with industry trends through internal meetups

In an ideal world, a perfect developer would find time to read professional articles, attend conferences, and work on pet projects. This is not always the case in the real world: fatigue at work, personal and family issues, going to a doctor — there are a million things to do and reasons to say “not today.”

That’s why our Android team created the “developing together” internal meetup format. We either prepare short presentations on new topics or watch professional videos together. We have time to do things after work, and our conscience isn’t burdened. Furthermore, we can discuss the applicability of what we heard immediately with our colleagues.

The meetups have been held for about half a year now. There is no restriction on the topics that speakers can choose, and everyone discusses what they have experienced in their current or previous jobs. The fact that we have several sub-teams allows people to learn things they’ve never heard of — and expand their horizons.

The selection of videos continuously varies: sometimes, it’s by voting list, sometimes by team lead selection. As a result, decisions are always subjective. But there are criteria on which it is based:

• Not too long: ideally, we should have time to watch and discuss it in an hour, and then go back to work
• Not overloaded with code: it’s hard to keep in mind all the code you see on a slide, so we prefer to read the topics where code is discussed in depth rather than just listening
• Content should be of high quality: so we often choose conference recordings, where presentations are carefully selected

Since topics with an abundance of code are difficult to learn, most everything related to elemental things (i.e. — performance monitoring) and development trends gets shortlisted.

As an example, here are some videos discussed at our recent internal meetups that we can recommend to watch:

Five Ways to Improve Your Android Productivity — a great story about proper dependency management and multi-modularity. Additionally, it was nice to see that almost all the things mentioned in the presentation have already been implemented in our company. Wow, we are cool :)

Understanding Android Memory Usage — a presentation on the internals of Android: what happens in the system when memory becomes scarce, and what to do with that. Although it’s a few years old, conceptually it still works. Now we do launches in the fastly developing world where some devices are not so new. Therefore this information comes in handy for us.

Improve App Performance With Android Studio Profilers — again, not the newest video, but conceptually the studio profiler hasn’t changed that much. However, not all developers use the profiler. That’s why it’s an excellent material for beginners, explained in simple terms: how to track, what objects are hanging, how the app behaves with memory, threads, etc.