Communities of practice in practice: Kotlin community at Tuenti
One of the things I like most at Tuenti is that they are always trying to boost the personal growth of its developers. And the truth is that, we are given a lot of facilities & support to make that happen.
As Joaquin Engelmo Moriche told us here, we have a large selection of options to improve and extend our knowledge. And recently we have enhanced our culture of learning, through the inclusion of communities of practice. Read on to know more about them.
Although here the whole concept is explained much better, we could summarize it by saying that a community of practice is a group of people interested in the same topic & wanting to learn more. The big advantage with such a community is that it allows for flexibility and to mould the program to grow in a more natural form, rather than have fixed boundaries and try to fit learning into those boundaries. And this is only made possible because such a community sees the coming together of a small group of people who’s willing to make mistakes, to not be worried about asking a silly question and make the community grow and mature. At Tuenti, as part of the personal growth boosting I mentioned above, we can develop the community during working hours because not only does this learning benefit the individual but also the company.
So say supposing we don’t have any experience in a particular area, we could just ignore and walk away or try to learn by ourselves and keep the knowledge to one person, but that’s not the Tuenti way. We, instead, get a group together and all of us jump on-board and learn and then put into practice what we learnt ;)
So let me tell you about the process by which we started the Kotlin community.
Our story
I was willing to learn Kotlin and the feeling was shared between several colleagues. We even had a group chat where we already posted links and created small flames, but nothing serious. So another friend and I took the first step: we decided to create the first community of practice at Tuenti: The Kotlin community.
Alright, and now what?
First, we asked for an internal email that we could manage, to not bother the IT team too much. We needed to have common communication point and, even if we had a group chat already, the power of what google groups offers is much bigger, as:
- Every new member can access all the information previously shared in the group.
- It is really easy to manage large groups of people
- Offline foros can be created to discuss a concrete topic, which in a group chat is hard to follow.
- It is integrated with all google tools: calendar, drive, hangouts, etc.
Once we had the email address, we advertised the existence of the community to the company and set up a 30-minute meeting to introduce it to those who could be interested. I have to confess that I was a bit nervous the day of the meeting: I wasn’t sure if people wanted to get involved in something like this. But the result was pretty amazing, about 20 people showed up. There wasn’t even as many people in the original group chat! Why did I even have doubts?! XD
That first meeting helped us to decide the amount of hours we wanted to dedicate. We also decided which learning tool we were going to use. In our case, JetBrains has developed Kotlin Koans, which is quite easy to follow as it is teaches the language based on practical exercises.
During the second meeting, we started to learn the language, but let’s be honest, it was a disaster XD: not everyone had the IDE installed or functional, others didn’t have the right plugin, etc… Once we solved that, we started with the exercises, reading the documentation and following the steps. We weren’t fast enough as we were all doing exactly the same thing and we were running out of time to discuss or solve doubts. We could say we didn’t learn much about Kotlin, but we definitely improved the community as we decided to distribute the topics of the tutorial between the members: Each one had to prepare one topic and explain it to the others in next meeting.
The truth is that it worked out much better than expected. We were faster this way and funnier, as we had more time to promote discussions over the topics. We even increased the frequency of the meetings, having them weekly, and we were seeing good results. Definitely, Kotlin had us hooked! We immediately saw we could combine the meetings with our daily job. If someone couldn’t make it to the meeting, his/her topic could be reviewed on the fly. And if another one was working remotely, well, what are videoconferences for, right? ;)
After a while, we reached a new step for us: we had finished the tutorial. Great. We “know” Kotlin. And now what? Do we end with the community? Noooooooo! We should put that knowledge in practice, right? But, how?
Tuenti codebase, as you might expect, is big and any inclusions to this would require being extra cautious. Any inclusion will need to clear many levels of compatibility as well as risk assessments before we can proceed. So with Kotlin, even though there are many articles and posts that showcase the results of testing on Android apps with quite satisfying results, there are others claiming right the opposite. Apart from that, Kotlin is not officially supported by Google yet, so if we want to take the risk and put it our production code, we should test it before in a real, mid-size project.
Therefore, our next step was to develop a side-project, a project not related with the Tuenti product but that, when developed, would be useful inside the company, so everyone can enjoy the benefits. This wouldn’t be the first time a side-project was developed at Tuenti, and hopefully not the last one either.
We brainstormed, voted the ideas and picked the two projects with more votes. We realized that the community was big enough for two projects! And this is where we are right now. We have built the skeleton of the projects and now we are doing some pair programming. I hope we can show you the code soon :)
Not all our meetings have been about following tutorials. The community has become really active. We share articles all the time, creating offline discussions about them. And online too, our group chat has been active. We have been in some tech talks about Kotlin, and soon we will start having some meetups at our office too. I have to say that I’m really proud of how the community is growing and becoming more mature. Thanks to every single member who said yes to taking a chance and who saw the power of coming together with a common purpose.
What have we learned?
With every single step we take, we learn from our mistakes and we improve the way we work. And even though it is possible that not all the communities have the same necessities, I do believe there are some important points to make it work that can be applied to all of them:
- Common communication point, like an email and/or a group chat. Never underestimate the power of communication!
- A kick-off meeting, to know who is interested, agree the frequency of the meetings and next steps to do. It is really important not to burn out at the beginning. The community has to adapt itself to the necessities of each moment.
- All members should participate and be proactive. Feedback is the secret sauce for success in groups of this kind.
- Balance between commitment and enthusiasm must be found: you cannot spend 100% of your time on the community, and you can’t say you’ll participate and then never show up either.
However, what has to be crystal clear is that a community should not be a burden. If you join one it should be because you want to learn something new and enjoy it. It has to be fun and should not stress you out. If you aren’t enjoying it, there definitely is a problem.
And what about you? Have you had any experience in setting up such communities? What worked for you and what did not? I’m eager to hear about your methods & of course, learn from them :)
