From the 11th of March until the 14th of June three students from UC Leuven embarked on their journey as interns at Kunlabora.
We’re very excited to talk about our time at Kunlabora, and hope we can help sketch a good image of what it’s like working here.
We all went into the internship with different angles. Simon already met people from Kunlabora through a workshop at school and later even a one day observation internship. When he saw Kunlabora offered a project he was interested in, he didn’t hesitate. Robbe followed a presentation at school by Kunlabora concerning a possible elective course. This made it so he recognised the name of the company in the enormous list of possible internship locations. Lenni didn’t know anything about Kunlabora at all and simply went through that giant list. One of the projects that Kunlabora offered matched really well with his interests.
Our internship consisted of coding for the Mezuri project. Mezuri is an app built in collaboration with Buurtwerk ’t Lampeke. It allows coaches to follow up on families in need based on text entries (i. e. diary fragments). Then, with machine learning algorithms we deduce how the coach who filled in said text fragments is feeling. Like this we try to get meaningful insights. Basically, the idea is to help these wonderful people with helping.
During the summer another team of students helped make the application. Now we come in to implement more functionality and iron out the rough parts.
We didn’t really know what to expect of our internship. There’s only so much you can really deduce from a job interview. We were looking for a place where we could grow, both as people and as developers, with the oppurtunity to get some real experience. Getting a good image of what our future job actually entails was an important goal.
The start of the internship was very overwhelming (in a good way) on the learning side of things. We had a MacBook put in front of us, something we weren’t used to. Not to mention the QWERTY layout of the keyboard …
On a technical level we also got to know Domain Driven Design, Mockito, Java features we didn’t know existed, Angular … It was a lot to take in, but we tried to absorb as much of the knowledge as we could and we think most of it did stick.
Something else we got into contact with properly for the first time was agile development. Before, we never really saw this outside of textbooks and articles. We can’t stress enough how great it was to work with Scrum meetings, retrospectives and sprints.
Throughout our journey at Kunlabora we had many people provide help and teaching to us.
Our team changed a lot over the months, but our rock was Kris Aerts. She was the proxy of our team and also our internship mentor. Any time we had functional questions we could discuss them with her. Also on all non technical aspects she provided an immense amount of support. How do I approach a retrospective? What’s expected from me during the Kunlabora Sync? What are concrete actions we can take to grow? Those and many more are all questions we could go to her for. Even if she couldn’t help much with the code, we’d like to make it very clear that we really appreciate her enthusiasm and help.
At the beginning of our run we were taught a lot by Thomas Vanausloos. He took the time to show us how the code works, how to approach Test Driven Development and help us prepare stories. In general he was there at all times for when we had questions or when a piece of code was being annoying. Thomas is the developer we learned the most from during our stay at Kunlabora.
Someone else who passed on a lot of knowledge was Bruno Lannoo. He showed us more of the operations side of Mezuri; things like Amazon Web Services, Docker and Jenkins. Those are aspects of development we never really got to see in a professional setting. Besides that he also helped us with writing cleaner code and provided many new insights.
Later on in our internship Seppe Gielen took over as technical-feedback-lead™ with fresh insights. He provided us with a lot of information around writing readable and maintainable code. When we had problems he would take the time to search for a solution with us. As a result we learned a lot from how he approaches problems.
Besides our team we also got help from other Kunlabora employees. Tom de Keyser comes to mind, who gave us functional feedback and even fixed a particularly nasty dependency issue for us. Pieter Bosman helped us by being a victim for our usability tests. Nele Veulemans was there to help us get settled in with email addresses, badges …
Last but not least we also learned a lot from each other.
After all that, we’d like to give more details on what our internship ended up being like.
Overall the three of us are really happy with the end result, Kunlabora and the internship as a whole. Kunlabora is a really interesting place to work, with a lot of internal events to participate in. In the future we’re definitely coming to the Kunlaboratoria, their open events.
Halfway through our internship something a little unexpected happened. Thomas and Bruno, who were on the Mezuri project at the time, were needed elsewhere, so the interns and Kris were “left alone”. Instead of just abandoning us, Kunlabora took measures to ensure we’d still get proper help, by planning weekly code review sessions and making sure we could always approach people with questions. In the end this change actually helped us to become more independent and more confident in our own abilities.
If we had to list all of the ways we got technical feedback it’d go something like this:
At all times we could just approach someone (even people outside of the team) and ask them directly how we could solve a problem.
Mostly at the start we would get together in a larger room with a big screen and start coding while passing the keyboard around. This was a great way to both see how experienced developers approach their work and to sink our own teeth into the application.
Throughout our entire internship we got to pair with others all the time. Most of the time this was one of the other interns but we did get to do pair programming with professional developers.
Preparation is key, and by giving and obtaining feedback on a technical story kickoff we managed to start working on the right foot.
Every week we would pick out commits or pieces of code we had questions about. During the code review sessions an experienced developer would look at the code together with us and share their thoughts.
When we first arrived Mezuri was already a working product. It was possible to enter diary fragments and see graphs based on machine learning. The students before us had done great work.
We added several new roles: one for the families and one administrator role.
Before, the sentiment analysis only showed what the algorithm calculated based on the diary fragments, but we added an emoticon registration that allows families to quickly express their own feelings. Now it’s possible to compare these emoticons with the sentiment analysis, which will refine insights.
The admins got a new screen to manage all the different tracks (timelines for different families), managing which coaches and families are paired with which tracks, inviting/removing users and archiving unused tracks.
Another screen for the administrators is a first iteration of a configuration screen where they can set a so called impact factor. Based on the keywords configured, a graph is shown in the analysis screens. It’s a first step to make Mezuri into something customizable!
Yet another new “graph” we added is a word cloud. With this we hope to make it easier to grasp at a glance what’s prevalent in a certain track. We also made it possible to click on points in the sentiment analysis graph and go directly to the relevant timeline entry.
We’ve completely redesigned the navigation. We did this after rounds of usability testing where it became clear that the previous navigation was not clear anymore after our additions.
A lot of work also went into things you can’t see.
We added a new end-to-end testing framework (Cypress)
We added Sentry, an application that’ll monitor errors thrown in Mezuri and post those directly to the chatting application of Kunlabora
Optimisations in regards to security, readability and performance were implemented
Restructuring the login system to work better with different environments
All of the previously mentioned features went through several iterations
After the previous 3 months we’ve learned a lot. And we mean a LOT. We’ve tried to summarize the most important things in a word cloud (made with Mezuri):
All three of us have a renewed love for software development because of this fantastic oppurtunity. Kunlabora has given us so much, we’re very grateful for having had such a great internship.