Konrad ‘ktoso’ Malawski at Scala Days: “With more type-safety, Akka will bring understandability to distributed systems.”

One of the first Scala adopters in Poland, Java Champion, member of the core Akka team at Lightbend and the citizen of the world (currently based in Japan), Konrad ‘ktoso’ Malawski is on a mission to make entering the Akka ecosystem and “using the right tool for the right job” simple and understandable, both for veterans and newcomers to Scala and Akka and distributed systems.

In advance of his talk at Scala Days, “Networks and Types — the Future of Akka”, we spoke to Konrad about his Akka journey, the biggest challenges Akka developers face today and whom he’s looking to connect with at Scala Days.

What’s your background and what does your current role involve?

My professional background is mostly from the JVM ecosystem, where I was a Java developer for a long time, before moving on to Scala (half-jokingly, I am known as one of the first Scala adopters in Poland).

I helped small startups achieve their performance requirements and advised larger corporations on how to get the most out their teams to create requirements and rollout systems that spanned multiple continents. I have lived in Austria, Poland, England, a few months in Sweden, and now, I  am located in Japan working for Lightbend, which is an awesome, remote-first team to work with.

At Lightbend, I am part of the core Akka team.  While I’ve worked on nearly every module over the years, I have spent the majority of my time on Persistence, Streams, and HTTP. I enjoy hacking and solving hard problems so others can leverage Akka to solve real-world business requirements. This involves quite a bit of collaboration with other teams around and within Lightbend, such as Scala, Play, and Lagom, as well as various cloud operators (AWS, Microsoft Azure, IBM Cloud, etc) to make sure Akka’s distributed features run well in all kinds of environments.

 

What’s the biggest highlight of your career so far?

I tend to not think of a career as having “the” highlight anywhere specifically; it’s more like a series of steps and milestones I’m proud of. Every month or so there’s a different thing I’m super proud of. I was awarded the title of Java Champion earlier this year, and this month we’re celebrating the 10th anniversary of a JVM languages and architecture focused conference – GeeCON – which I’ve been co-organizing. All of those are really amazing milestones, but that’s how I think of them, milestones along the way to next the things!

Working on Akka this year, we’ve had awesome milestones, like the 10.x Akka HTTP release series. I am incredibly proud of myself and of the community that we built around that project. Similarly, I am excited about my work in shaping the Reactive Streams TCK and building that community Reactive Streams TCK has been incorporated into the JDK since Java 9 – with the inclusion of java.util.concurrent.Flow. So, there have been tons of highlights, and I can’t wait to see what’s coming next.

 

Why did you pick Akka and what kind of problems do they solve for you?

I first saw Akka presented by Jonas Bonér in Kraków during our Polish Java User Group meetup shortly after he had released the project (around 2009, timeline). The initial version was already showing a lot of promise. I did not end up using it for a while though until I faced a project where we needed to speed up and parallelize data imports and data crunching for large datasets. That’s where I first ended up using Akka, and the speedups we were able to achieve on both the data import and service layers were impressive to both the developers and the business. After that, I worked on similar things at eBay, finally ending up at Typesafe/Lightbend to help build the library as a full(-or more) time job.

 

What’s the most important challenge Akka developers are facing today?

The toughest challenge I see developers and architects struggle with is finding a way to ship their ideas and products quickly, while not sacrificing resilience, responsiveness, and the other Reactive traits. Akka has always excelled at the latter – being true to the Reactive traits of resilience, elasticity, and responsiveness, while we have made it simpler to achieve those traits with Akka, it still is quite a big mental jump for developers to grasp this new paradigm. I think that finding ways to help people make this “jump” will have a huge positive impact on projects that face modern-day reactive systems development challenges.

 

What’s one thing that could address this challenge?

This is something that’s on my mind constantly, as we try to make entering the Akka ecosystem and “using the right tool for the right job” simple and understandable, not only to veterans but also for newcomers to Scala and/or Akka and distributed systems.

We have tried to solve this with more restrictive yet “guided” APIs, which often lead to good results, as long as developers didn’t need to step out of those guiding boundaries. This year we want to make the mixing of the guided and “power user” styles more natural and understandable.

If I were to identify the one thing that can help address this challenge, I think it would be better ways of visualizing and understanding distributed and concurrent systems. (In fact, Eric Loots and Kiki Carter from Lightbend and Brian Benz from Microsoft are hosting a workshop “Understanding Akka Cluster Through Raspberry-Pi Cluster Visualization” during Scala Days and I recommend you to check it out!) And I do hope we’ll have some nice projects, docs, and improvements to help in this area during 2018.

 

Who should attend your talk at Scala Days and why?

My talk Networks and Types — the Future of Akka will focus on the last 3 or 4 years of our(the Akka teams’) life and daily bread and butter – bringing Types back to Akka and concurrent / distributed systems as a whole. If you look at Akka Streams, which has been stable for a few years now, it is fully “typed” already. The same can be said about Akka HTTP, which also features a fully typed HTTP model and directives system. Yet, a common complaint about Akka remains the lack of type-safety, which, of course, is specifically about Actors.

Last year we continued to work on “Akka Typed” and this year we are aiming to announce it as production ready, including all modules relating to Actors such as Persistence and the Cluster. In the talk, I’ll give an overview of the design tradeoffs, ideas, and patterns that will shape what future Akka codebases will look like in this new Typed era of the project and ecosystem.

 

Whom would you like to connect with at the conference?

I’m always looking to get feedback from real projects and people on how we can improve Akka and its entire ecosystem to become even more useful.

There are plenty tangible results of such feedback. For example, earlier this month we (Lightbend) announced the formation of the Alpakka team to provide a dedicated focus on maintaining and developing all kinds of Akka Streams connectors. This is something the Akka team has been working on for more than a year, however, by an active response of the community to this project, and many real-life interactions, we were able to gather confirmation that dedicating staffing would be useful to a wide range of people. I’m curious what the discussions will be about this time around at Scala Days!

 

Don’t miss Konrad and his talk “Networks and Types — the Future of Akka” at Scala Days in New York on June 20th. Book your ticket now.

Leave a Reply